Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 7684b18e8fec45355a49e7f7165c582efc553ab6 / . / delegate / src / test / UnidirectionalSequenceLstmTest.cpp
blob: f0a96da57edf4e7040a0d850b3d93b95d60c8240 [file] [log] [blame]
Narumol Prangnawarat7684b182021-08-12 14:48:15 +0100[diff] [blame^]1//
2// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
3// SPDX-License-Identifier: MIT
4//
5
6#include "UnidirectionalSequenceLstmTestHelper.hpp"
7
8#include <armnn_delegate.hpp>
9
10#include <flatbuffers/flatbuffers.h>
11#include <tensorflow/lite/schema/schema_generated.h>
12#include <doctest/doctest.h>
13
14namespace armnnDelegate
15{
16
17void UnidirectionalSequenceLstmTest(std::vector<armnn::BackendId>& backends)
18{
19 int32_t batchSize = 3;
20 int32_t timeSize = 2;
21 int32_t inputSize = 3;
22 int32_t outputSize = 4;
23 // cellSize and outputSize have the same size when there is no projection.
24 int32_t numUnits = outputSize;
25
26 //tensorInfo12,
27 bool hasInputToInputWeights = true;
28 std::vector<float> inputToInputWeights = { -0.49536117f, -0.0556083915f, -0.102400711f,
29 -0.117484632f, 0.3298470976f, -0.1179017122f,
30 0.214305695f, 0.42135173085f, 0.003878414626f,
31 -0.348303917f, -0.1881275477f, 0.0343011027f };
32
33 std::vector<float> inputToForgetWeights = { 0.2415594226f, 0.15400093799f, 0.4566498398f,
34 -0.3810434485f, 0.268383264f, -0.009807467424f,
35 -0.3522925403f, -0.24275735512f, -0.28344226125f,
36 0.13512269116f, -0.4932442977f, -0.10039821991f };
37
38 std::vector<float> inputToCellWeights = { -0.2504855627f, 0.184490025045f, -0.2480507493f,
39 0.386399507f, -0.259465157985f, -0.16545993089f,
40 -0.4230232555f, 0.341664791103f, -0.18127849691f,
41 -0.2277662414f, -0.55275535589f, 0.34184026718f };
42
43 std::vector<float> inputToOutputWeights = { 0.2303854227f, 0.5218806862f, -0.4865379333f,
44 0.53969591851f, 0.23393625035f, -0.27140527306f,
45 0.50009280443f, 0.07511717046f, 0.3998299249f,
46 -0.51717478049f, 0.1889653282f, -0.367323637f };
47
48 //tensorInfo16,
49 bool hasRecurrentToInputWeights = true;
50 std::vector<float> recurrentToInputWeights = { -0.128009796112f, 0.1995525098f, -0.07745539397f, 0.1558421701f,
51 -0.265254765766f, -0.38837709614f, -0.05636804124f, 0.4259087456f,
52 0.17628988623f, 0.3877420127f, 0.53300309181f, -0.0959980934f,
53 0.00302857416f, 0.3266998827f, -0.142509296562f, -0.04433270756f };
54
55 std::vector<float> recurrentToForgetWeights = { -0.09499983487f, -0.08814888417f, -0.04834804721f, 0.1516668247f,
56 -0.3967529535f, -0.06463699788f, 0.4952811002f, 0.003274492938f,
57 -0.0968840941f, 0.17928104102f, 0.0031281141592f, -0.3387276584f,
58 -0.3587934076f, 0.06705895066f, 0.22463923692f, 0.1961955726f };
59
60 std::vector<float> recurrentToCellWeights = { -0.21938985582f, -0.3023648226f, -0.1170005202f, -0.3509177422f,
61 -0.4286288613f, 0.2726137042f, 0.09216640889f, -0.06551410215f,
62 0.20453298098f, 0.2393476665f, 0.11846517771f, 0.2630801796f,
63 0.3954237699f, -0.19407111404f, 0.30412107706f, -0.27342408554f };
64
65 std::vector<float> recurrentToOutputWeights = { -0.32921677827f, 0.32624614238f, -0.1388191282f, -0.17879831790f,
66 -0.15185534954f, -0.16918526583f, -0.10087361183f, -0.5436913968f,
67 0.016758225858f, 0.30454617738f, -0.41493862867f, -0.005565764375f,
68 -0.12584099173f, -0.12319286912f, 0.2407919466f, -0.08879069983f };
69 // tensorInfo4
70 bool hasCellToInputWeights = false;
71 std::vector<float> cellToInputWeights;
72 bool hasCellToForgetWeights = false;
73 std::vector<float> cellToForgetWeights;
74 bool hasCellToOutputWeights = false;
75 std::vector<float> cellToOutputWeights;
76
77 bool hasInputGateBias = true;
78 std::vector<float> inputGateBias = {0., 0., 0., 0.};
79 std::vector<float> forgetGateBias = {1., 1., 1., 1.};
80 std::vector<float> cellBias = {0., 0., 0., 0.};
81 std::vector<float> outputGateBias = {0., 0., 0., 0.};
82
83 bool hasProjectionWeights = false;
84 std::vector<float> projectionWeights;
85 bool hasProjectionBias = false;
86 std::vector<float> projectionBias;
87
88 bool hasInputLayerNormWeights = false;
89 std::vector<float> inputLayerNormWeights;
90 bool hasForgetLayerNormWeights = false;
91 std::vector<float> forgetLayerNormWeights;
92 bool hasCellLayerNormWeights = false;
93 std::vector<float> cellLayerNormWeights;
94 bool hasOutputLayerNormWeights = false;
95 std::vector<float> outputLayerNormWeights;
96
97 std::vector<float> inputValues = { 1., 2., 3., 4., 5., 4.,
98 3., 2., 1., 2., 3., 4.,
99 5., 4., 3., 2., 1., 2. };
100 std::vector<float> expectedOutputValues = { -0.0714901f, -0.162117f, -0.175168f, -0.0232934f,
101 -0.168107f, -0.414129f, -0.549875f, -0.00803579f,
102 -0.0668735f, 0.204078f, -0.42765f, -0.0312321f,
103 -0.120003f, -0.0941918f, -0.456391f, -0.0287019f,
104 -0.0342921f, 0.20824f, -0.656989f, -0.00415265f,
105 -0.10493f, 0.14211f, -0.583478f, -0.0329754f };
106
107 tflite::ActivationFunctionType activationFunction = tflite::ActivationFunctionType_TANH;
108 float clippingThresCell = 10.f;
109 float clippingThresProj = 0.f;
110 bool isTimeMajor = false;
111
112 UnidirectionalSequenceLstmTestImpl<float>(backends,
113 ::tflite::TensorType_FLOAT32,
114 batchSize,
115 timeSize,
116 inputSize,
117 outputSize,
118 numUnits,
119 hasInputToInputWeights,
120 inputToInputWeights,
121 inputToForgetWeights,
122 inputToCellWeights,
123 inputToOutputWeights,
124 hasRecurrentToInputWeights,
125 recurrentToInputWeights,
126 recurrentToForgetWeights,
127 recurrentToCellWeights,
128 recurrentToOutputWeights,
129 hasCellToInputWeights,
130 cellToInputWeights,
131 hasCellToForgetWeights,
132 cellToForgetWeights,
133 hasCellToOutputWeights,
134 cellToOutputWeights,
135 hasInputGateBias,
136 inputGateBias,
137 forgetGateBias,
138 cellBias,
139 outputGateBias,
140 hasProjectionWeights,
141 projectionWeights,
142 hasProjectionBias,
143 projectionBias,
144 hasInputLayerNormWeights,
145 inputLayerNormWeights,
146 hasForgetLayerNormWeights,
147 forgetLayerNormWeights,
148 hasCellLayerNormWeights,
149 cellLayerNormWeights,
150 hasOutputLayerNormWeights,
151 outputLayerNormWeights,
152 inputValues,
153 expectedOutputValues,
154 activationFunction,
155 clippingThresCell,
156 clippingThresProj,
157 isTimeMajor);
158}
159
160void UnidirectionalSequenceLstmTimeMajorTest(std::vector<armnn::BackendId>& backends)
161{
162 int32_t batchSize = 3;
163 int32_t timeSize = 2;
164 int32_t inputSize = 3;
165 int32_t outputSize = 4;
166 // cellSize and outputSize have the same size when there is no projection.
167 int32_t numUnits = outputSize;
168
169 std::vector<int32_t> inputShape = {timeSize, batchSize, inputSize};
170 std::vector<int32_t> cellStateInTensorInfo = {batchSize, numUnits};
171 std::vector<int32_t> outputStateInTensorInfo = {batchSize, outputSize};
172
173 std::vector<int32_t> outputTensorInfo = {timeSize, batchSize, outputSize};
174
175 //tensorInfo12
176 bool hasInputToInputWeights = true;
177 std::vector<float> inputToInputWeights = { 0.27277296781539917f, 0.3813590407371521f, -0.394489049911499f,
178 0.2782636880874634f, -0.3793870210647583f, -0.018918335437774658f,
179 0.2724653482437134f, -0.19314253330230713f, -0.2947450876235962f,
180 -0.30253493785858154f, 0.4241350293159485f, -0.22560018301010132f };
181
182 std::vector<float> inputToForgetWeights = { -0.2667974531650543f, -0.05505800247192383f, -0.20932340621948242f,
183 -0.14345619082450867f, 0.09666192531585693f, -0.2604355812072754f,
184 -0.2681812047958374f, -0.3314584493637085f, 0.4485899806022644f,
185 -0.23467743396759033f, 0.5072842240333557f, -0.4192768931388855f };
186
187 std::vector<float> inputToCellWeights = { -0.15782442688941956f, -0.027530014514923096f, 0.4789854884147644f,
188 0.23227906227111816f, 0.28259342908859253f, -0.030095696449279785f,
189 0.10071521997451782f, -0.08535495400428772f, 0.18563997745513916f,
190 -0.3049069046974182f, -0.478048175573349f, 0.025234103202819824f };
191
192 std::vector<float> inputToOutputWeights = { -0.04584759473800659f, -0.2716066539287567f, 0.012970447540283203f,
193 -0.4729190170764923f, -0.37422770261764526f, 0.49352723360061646f,
194 0.3163864016532898f, -0.436781644821167f, -0.33074596524238586f,
195 -0.32885751128196716f, -0.40959352254867554f, -0.2124689817428589f };
196
197 //tensorInfo16
198 bool hasRecurrentToInputWeights = true;
199 std::vector<float> recurrentToInputWeights = { 0.23788475990f, -0.24948765337f, 0.50044941902f, 0.14431896805f,
200 -0.115940228137f, -0.717082679f, -0.17208620906f, 0.17850610617f,
201 -0.16702319684f, -0.11384502053f, -0.309785276245f, -0.3316611672f,
202 0.52380162477f, -0.06839632987f, -0.391478359627f, -0.10756178963f };
203
204 std::vector<float> recurrentToForgetWeights = { 0.11383482068f, 0.1676601767f, -0.08550968004f, 0.03399394089f,
205 0.08042152225f, -0.2133381964f, 0.05182432704f, 0.38161808255f,
206 -0.5018365979f, -0.08043262364f, 0.07894329014f, -0.07547105155f,
207 0.12047368288f, 0.2986997961f, 0.0485043078f, -0.13372567296f };
208
209 std::vector<float> recurrentToCellWeights = { 0.0433832928545f, 0.07587072294f, -0.120520234107f, 0.604576051f,
210 -0.434353142986f, 0.009314475068f, 0.005085289478f, 0.08488202038f,
211 -0.00025437487886f, 0.15245915082f, -0.1936587542f, 0.004754020f,
212 -0.1582719236f, 0.3307867646f, 0.0236605107784f, 0.307716339826f };
213
214 std::vector<float> recurrentToOutputWeights = { -0.079031050201f, 0.041414566286f, -0.583727357285f, 0.1025384515f,
215 -0.172372072937f, 0.09214124082f, 0.178184121827f, -0.2439443916f,
216 0.104485116899f, 0.2600405514f, 0.064414866268f, 0.24141204357f,
217 0.281875759363f, -0.14234502664f, 0.15126448862f, -0.24421440064f };
218 // tensorInfo4
219 bool hasCellToInputWeights = false;
220 std::vector<float> cellToInputWeights;
221 bool hasCellToForgetWeights = false;
222 std::vector<float> cellToForgetWeights;
223 bool hasCellToOutputWeights = false;
224 std::vector<float> cellToOutputWeights;
225
226 bool hasInputGateBias = true;
227 std::vector<float> inputGateBias = {0., 0., 0., 0.};
228 std::vector<float> forgetGateBias = {1., 1., 1., 1.};
229 std::vector<float> cellBias = {0., 0., 0., 0.};
230 std::vector<float> outputGateBias = {0., 0., 0., 0.};
231
232 bool hasProjectionWeights = false;
233 std::vector<float> projectionWeights;
234 bool hasProjectionBias = false;
235 std::vector<float> projectionBias;
236
237 bool hasInputLayerNormWeights = false;
238 std::vector<float> inputLayerNormWeights;
239 bool hasForgetLayerNormWeights = false;
240 std::vector<float> forgetLayerNormWeights;
241 bool hasCellLayerNormWeights = false;
242 std::vector<float> cellLayerNormWeights;
243 bool hasOutputLayerNormWeights = false;
244 std::vector<float> outputLayerNormWeights;
245
246 std::vector<float> inputValues = { 1., 2., 3., 4., 5., 4.,
247 3., 2., 1., 2., 3., 4.,
248 5., 4., 3., 2., 1., 2. };
249 std::vector<float> expectedOutputValues = { 0.135658f, 0.124673f, 0.021209f, -0.0530204f,
250 0.106138f, 0.0404792f, 0.0151644f, -0.00675166f,
251 -0.0128514f, 0.0644884f, 0.0709072f, -0.0454045f,
252 0.162886f, 0.166494f, 0.0277046f, -0.0369807f,
253 0.111716f, 0.043119f, 0.0762981f, -0.0122854f,
254 0.104397f, 0.2144f, 0.119192f, -0.0839058f };
255
256 tflite::ActivationFunctionType activationFunction = tflite::ActivationFunctionType_TANH;
257 float clippingThresCell = 10.f;
258 float clippingThresProj = 0.f;
259 bool isTimeMajor = true;
260
261 UnidirectionalSequenceLstmTestImpl<float>(backends,
262 ::tflite::TensorType_FLOAT32,
263 batchSize,
264 timeSize,
265 inputSize,
266 outputSize,
267 numUnits,
268 hasInputToInputWeights,
269 inputToInputWeights,
270 inputToForgetWeights,
271 inputToCellWeights,
272 inputToOutputWeights,
273 hasRecurrentToInputWeights,
274 recurrentToInputWeights,
275 recurrentToForgetWeights,
276 recurrentToCellWeights,
277 recurrentToOutputWeights,
278 hasCellToInputWeights,
279 cellToInputWeights,
280 hasCellToForgetWeights,
281 cellToForgetWeights,
282 hasCellToOutputWeights,
283 cellToOutputWeights,
284 hasInputGateBias,
285 inputGateBias,
286 forgetGateBias,
287 cellBias,
288 outputGateBias,
289 hasProjectionWeights,
290 projectionWeights,
291 hasProjectionBias,
292 projectionBias,
293 hasInputLayerNormWeights,
294 inputLayerNormWeights,
295 hasForgetLayerNormWeights,
296 forgetLayerNormWeights,
297 hasCellLayerNormWeights,
298 cellLayerNormWeights,
299 hasOutputLayerNormWeights,
300 outputLayerNormWeights,
301 inputValues,
302 expectedOutputValues,
303 activationFunction,
304 clippingThresCell,
305 clippingThresProj,
306 isTimeMajor);
307}
308
309void UnidirectionalSequenceLstmNoCifgWithPeepholeWithProjectionTest(std::vector<armnn::BackendId>& backends)
310{
311 int32_t batchSize = 2;
312 int32_t timeSize = 3;
313 int32_t inputSize = 4;
314 int32_t outputSize = 5;
315 int32_t numUnits = 6;
316
317 std::vector<int32_t> inputShape = {batchSize, timeSize, inputSize};
318 std::vector<int32_t> cellStateInTensorInfo = {batchSize, numUnits};
319 std::vector<int32_t> outputStateInTensorInfo = {batchSize, outputSize};
320
321 std::vector<int32_t> outputTensorInfo = {batchSize, timeSize, outputSize};
322
323 //tensorInfoInputSize,
324 bool hasInputToInputWeights = true;
325 std::vector<float> inputToInputWeights = { 0.021393683f, 0.06124551f, 0.046905167f, -0.014657677f,
326 -0.03149463f, 0.09171803f, 0.14647801f, 0.10797193f,
327 -0.0057968358f, 0.0019193048f, -0.2726754f, 0.10154029f,
328 -0.018539885f, 0.080349885f, -0.10262385f, -0.022599787f,
329 -0.09121155f, -0.008675967f, -0.045206103f, -0.0821282f,
330 -0.008045952f, 0.015478081f, 0.055217247f, 0.038719587f };
331
332 std::vector<float> inputToForgetWeights = { -0.0018401089f, -0.004852237f, 0.03698424f, 0.014181704f,
333 0.028273236f, -0.016726194f, -0.05249759f, -0.10204261f,
334 0.00861066f, -0.040979505f, -0.009899187f, 0.01923892f,
335 -0.028177269f, -0.08535103f, -0.14585495f, 0.10662567f,
336 -0.01909731f, -0.017883534f, -0.0047269356f, -0.045103323f,
337 0.0030784295f, 0.076784775f, 0.07463696f, 0.094531395f};
338
339 std::vector<float> inputToCellWeights = { -0.04580283f, -0.09549462f, -0.032418985f, -0.06454633f,
340 -0.043528453f, 0.043018587f, -0.049152344f, -0.12418144f,
341 -0.078985475f, -0.07596889f, 0.019484362f, -0.11434962f,
342 -0.0074034138f, -0.06314844f, -0.092981495f, 0.0062155537f,
343 -0.025034338f, -0.0028890965f, 0.048929527f, 0.06235075f,
344 0.10665918f, -0.032036792f, -0.08505916f, -0.10843358f };
345
346 std::vector<float> inputToOutputWeights = { -0.0998932f, -0.07201956f, -0.052803773f, -0.15629593f,
347 -0.15001918f, -0.07650751f, 0.02359855f, -0.075155355f,
348 -0.08037709f, -0.15093534f, 0.029517552f, -0.04751393f,
349 0.010350531f, -0.02664851f, -0.016839722f, -0.023121163f,
350 0.0077019283f, 0.012851257f, -0.05040649f, -0.0129761f,
351 -0.021737747f, -0.038305793f, -0.06870586f, -0.01481247f };
352
353 //tensorInfoOutputSize,
354 bool hasRecurrentToInputWeights = true;
355 std::vector<float> recurrentToInputWeights = { -0.001374326f, -0.078856036f, 0.10672688f, 0.029162422f,
356 -0.11585556f, 0.02557986f, -0.13446963f, -0.035785314f,
357 -0.01244275f, 0.025961924f, -0.02337298f, -0.044228926f,
358 -0.055839065f, -0.046598054f, -0.010546039f, -0.06900766f,
359 0.027239809f, 0.022582639f, -0.013296484f, -0.05459212f,
360 0.08981f, -0.045407712f, 0.08682226f, -0.06867011f,
361 -0.14390695f, -0.02916037f, 0.000996957f, 0.091420636f,
362 0.14283475f, -0.07390571f };
363
364 std::vector<float> recurrentToForgetWeights = { -0.057784554f, -0.026057621f, -0.068447545f, -0.022581743f,
365 0.14811787f, 0.10826372f, 0.09471067f, 0.03987225f,
366 -0.0039523416f, 0.00030638507f, 0.053185795f, 0.10572994f,
367 0.08414449f, -0.022036452f, -0.00066928595f, -0.09203576f,
368 0.032950465f, -0.10985798f, -0.023809856f, 0.0021431844f,
369 -0.02196096f, -0.00326074f, 0.00058621005f, -0.074678116f,
370 -0.06193199f, 0.055729095f, 0.03736828f, 0.020123724f,
371 0.061878487f, -0.04729229f };
372
373 std::vector<float> recurrentToCellWeights = { -0.037322544f, 0.018592842f, 0.0056175636f, -0.06253426f,
374 0.055647098f, -0.05713207f, -0.05626563f, 0.005559383f,
375 0.03375411f, -0.025757805f, -0.088049285f, 0.06017052f,
376 -0.06570978f, 0.007384076f, 0.035123326f, -0.07920549f,
377 0.053676967f, 0.044480428f, -0.07663568f, 0.0071805613f,
378 0.08089997f, 0.05143358f, 0.038261272f, 0.03339287f,
379 -0.027673481f, 0.044746667f, 0.028349208f, 0.020090483f,
380 -0.019443132f, -0.030755889f };
381
382 std::vector<float> recurrentToOutputWeights = { 0.025825322f, -0.05813119f, 0.09495884f,
383 -0.045984812f,-0.01255415f, -0.0026479573f,
384 -0.08196161f, -0.054914974f, -0.0046604523f,
385 -0.029587349f, -0.044576716f, -0.07480124f,
386 -0.082868785f, 0.023254942f, 0.027502948f,
387 -0.0039728214f, -0.08683098f, -0.08116779f,
388 -0.014675607f, -0.037924774f, -0.023314456f,
389 -0.007401714f, -0.09255757f, 0.029460307f,
390 -0.08829125f, -0.005139627f, -0.08989442f,
391 -0.0555066f, 0.13596267f, 0.025062224f };
392 // tensorInfoNumUnits
393 bool hasCellToInputWeights = true;
394 std::vector<float> cellToInputWeights = { 0.040369894f, 0.030746894f, 0.24704495f,
395 0.018586371f, -0.037586458f, -0.15312155f };
396 bool hasCellToForgetWeights = true;
397 std::vector<float> cellToForgetWeights = { -0.01998659f, -0.15568835f, -0.24248174f,
398 -0.012770197f, 0.041331276f, -0.072311886f };
399 bool hasCellToOutputWeights = true;
400 std::vector<float> cellToOutputWeights = { 0.08286371f, -0.08261836f, -0.51210177f,
401 0.002913762f, 0.17764764f, -0.5495371f };
402
403 bool hasInputGateBias = true;
404 std::vector<float> inputGateBias = { 0.02234832f, 0.14757581f, 0.18176508f,
405 0.10380666f, 0.053110216f, -0.06928846f };
406 std::vector<float> forgetGateBias = { 0.035185695f, -0.042891346f, -0.03032477f,
407 0.23027696f, 0.11098921f, 0.08989442f };
408 std::vector<float> cellBias = { -0.024379363f, 0.0055531194f, 0.23377132f,
409 0.033463873f, -0.1483596f, 0.029460307f };
410 std::vector<float> outputGateBias = { 0.046159424f, -0.0012809046f, 0.03563469f,
411 0.12648113f, 0.027195795f, 0.35373217f };
412
413 bool hasProjectionWeights = true;
414 std::vector<float> projectionWeights = { -0.009802181f, 0.09401916f, 0.0717386f, -0.13895074f, 0.09641832f,
415 0.060420845f, 0.08539281f, 0.054285463f, 0.061395317f, 0.034448683f,
416 -0.042991187f, 0.019801661f, -0.16840284f, -0.015726732f, -0.23041931f,
417 -0.024478018f, -0.10959692f, -0.013875541f, 0.18600968f, -0.061274476f,
418 0.0138165f, -0.08160894f, -0.07661644f, 0.032372914f, 0.16169067f,
419 0.22465782f, -0.03993472f, -0.004017731f, 0.08633481f, -0.28869787f };
420
421 bool hasProjectionBias = true;
422 std::vector<float> projectionBias(outputSize, 0.f);
423
424 bool hasInputLayerNormWeights = false;
425 std::vector<float> inputLayerNormWeights;
426 bool hasForgetLayerNormWeights = false;
427 std::vector<float> forgetLayerNormWeights;
428 bool hasCellLayerNormWeights = false;
429 std::vector<float> cellLayerNormWeights;
430 bool hasOutputLayerNormWeights = false;
431 std::vector<float> outputLayerNormWeights;
432
433 std::vector<float> inputValues = { 1., 2., 3., 4., 5., 4.,
434 3., 2., 1., 2., 3., 4.,
435 5., 4., 3., 2., 1., 2.,
436 1., 2., 3., 4., 5., 4.};
437 std::vector<float> expectedOutputValues = { -0.0135612f, -0.0263441f, 0.0314008f, -0.00883455f, 0.00763052f,
438 -0.00126877f, -0.0292959f, 0.0449957f, -0.00976195f, -0.00492338f,
439 -0.0175702f, -0.0431753f, 0.0597117f, -0.0169154f, 0.0142087f,
440 0.00472515f, -0.0196355f, 0.0342524f, -0.00407936f, -0.0253189f,
441 -0.00512944f, -0.0293754f, 0.0512771f, -0.0151874f, -0.0246433f,
442 -0.00744986f, -0.0345103f, 0.0450666f, -0.00944991f, 0.0126895f };
443
444 tflite::ActivationFunctionType activationFunction = tflite::ActivationFunctionType_TANH;
445 float clippingThresCell = 10.f;
446 float clippingThresProj = 0.f;
447 bool isTimeMajor = false;
448
449 UnidirectionalSequenceLstmTestImpl<float>(backends,
450 ::tflite::TensorType_FLOAT32,
451 batchSize,
452 timeSize,
453 inputSize,
454 outputSize,
455 numUnits,
456 hasInputToInputWeights,
457 inputToInputWeights,
458 inputToForgetWeights,
459 inputToCellWeights,
460 inputToOutputWeights,
461 hasRecurrentToInputWeights,
462 recurrentToInputWeights,
463 recurrentToForgetWeights,
464 recurrentToCellWeights,
465 recurrentToOutputWeights,
466 hasCellToInputWeights,
467 cellToInputWeights,
468 hasCellToForgetWeights,
469 cellToForgetWeights,
470 hasCellToOutputWeights,
471 cellToOutputWeights,
472 hasInputGateBias,
473 inputGateBias,
474 forgetGateBias,
475 cellBias,
476 outputGateBias,
477 hasProjectionWeights,
478 projectionWeights,
479 hasProjectionBias,
480 projectionBias,
481 hasInputLayerNormWeights,
482 inputLayerNormWeights,
483 hasForgetLayerNormWeights,
484 forgetLayerNormWeights,
485 hasCellLayerNormWeights,
486 cellLayerNormWeights,
487 hasOutputLayerNormWeights,
488 outputLayerNormWeights,
489 inputValues,
490 expectedOutputValues,
491 activationFunction,
492 clippingThresCell,
493 clippingThresProj,
494 isTimeMajor);
495}
496
497void UnidirectionalSequenceLstmWithCifgWithPeepholeNoProjectionTest(std::vector<armnn::BackendId>& backends)
498{
499 int32_t batchSize = 3;
500 int32_t timeSize = 2;
501 int32_t inputSize = 3;
502 int32_t outputSize = 4;
503 // cellSize and outputSize have the same size when there is no projection.
504 int32_t numUnits = outputSize;
505
506 //tensorInfo12
507 bool hasInputToInputWeights = false;
508 std::vector<float> inputToInputWeights{};
509
510 std::vector<float> inputToForgetWeights = { 0.2415594226f, 0.15400093799f, 0.4566498398f,
511 -0.3810434485f, 0.268383264f, -0.009807467424f,
512 -0.3522925403f, -0.24275735512f, -0.28344226125f,
513 0.13512269116f, -0.4932442977f, -0.10039821991f };
514
515 std::vector<float> inputToCellWeights = { -0.2504855627f, 0.184490025045f, -0.2480507493f,
516 0.386399507f, -0.259465157985f, -0.16545993089f,
517 -0.4230232555f, 0.341664791103f, -0.18127849691f,
518 -0.2277662414f, -0.55275535589f, 0.34184026718f };
519
520 std::vector<float> inputToOutputWeights = { 0.2303854227f, 0.5218806862f, -0.4865379333f,
521 0.53969591851f, 0.23393625035f, -0.27140527306f,
522 0.50009280443f, 0.07511717046f, 0.3998299249f,
523 -0.51717478049f, 0.1889653282f, -0.367323637f };
524
525 //tensorInfo16
526 bool hasRecurrentToInputWeights = false;
527 std::vector<float> recurrentToInputWeights{};
528
529 std::vector<float> recurrentToForgetWeights = { -0.09499983487f, -0.08814888417f, -0.04834804721f, 0.1516668247f,
530 -0.3967529535f, -0.06463699788f, 0.4952811002f, 0.003274492938f,
531 -0.0968840941f, 0.17928104102f, 0.0031281141592f, -0.3387276584f,
532 -0.3587934076f, 0.06705895066f, 0.22463923692f, 0.1961955726f };
533
534 std::vector<float> recurrentToCellWeights = { -0.21938985582f, -0.3023648226f, -0.1170005202f, -0.3509177422f,
535 -0.4286288613f, 0.2726137042f, 0.09216640889f, -0.06551410215f,
536 0.20453298098f, 0.2393476665f, 0.11846517771f, 0.2630801796f,
537 0.3954237699f, -0.19407111404f, 0.30412107706f, -0.27342408554f };
538
539 std::vector<float> recurrentToOutputWeights = { -0.32921677827f, 0.32624614238f, -0.1388191282f, -0.17879831790f,
540 -0.15185534954f, -0.16918526583f, -0.10087361183f, -0.5436913968f,
541 0.016758225858f, 0.30454617738f, -0.41493862867f, -0.005565764375f,
542 -0.12584099173f, -0.12319286912f, 0.2407919466f, -0.08879069983f };
543 // tensorInfo4
544 bool hasCellToInputWeights = false;
545 std::vector<float> cellToInputWeights;
546 bool hasCellToForgetWeights = true;
547 std::vector<float> cellToForgetWeights = {0.47485286f, -0.51955009f, -0.24458408f, 0.31544167f};
548 bool hasCellToOutputWeights = true;
549 std::vector<float> cellToOutputWeights = {-0.17135078f, 0.82760304f, 0.85573703f, -0.77109635f};
550
551 bool hasInputGateBias = false;
552 std::vector<float> inputGateBias;
553 std::vector<float> forgetGateBias = {1., 1., 1., 1.};
554 std::vector<float> cellBias = {0., 0., 0., 0.};
555 std::vector<float> outputGateBias = {0., 0., 0., 0.};
556
557 bool hasProjectionWeights = false;
558 std::vector<float> projectionWeights;
559 bool hasProjectionBias = false;
560 std::vector<float> projectionBias;
561
562 bool hasInputLayerNormWeights = false;
563 std::vector<float> inputLayerNormWeights;
564 bool hasForgetLayerNormWeights = false;
565 std::vector<float> forgetLayerNormWeights;
566 bool hasCellLayerNormWeights = false;
567 std::vector<float> cellLayerNormWeights;
568 bool hasOutputLayerNormWeights = false;
569 std::vector<float> outputLayerNormWeights;
570
571 std::vector<float> inputValues = { 1., 2., 3., 4., 5., 4.,
572 3., 2., 1., 2., 3., 4.,
573 5., 4., 3., 2., 1., 2. };
574 std::vector<float> expectedOutputValues = { -0.0129257f, -0.070531f, -0.153508f, -0.0392391f,
575 -0.0300169f, -0.195717f, -0.528679f, -0.0818106f,
576 -0.0332748f, 0.155429f, -0.353966f, -0.0801505f,
577 -0.032312f, -0.0407911f, -0.435053f, -0.0932317f,
578 -0.0108233f, 0.165584f, -0.640424f, -0.0447535f,
579 -0.031675f, 0.125987f, -0.526695f, -0.110093f };
580
581 tflite::ActivationFunctionType activationFunction = tflite::ActivationFunctionType_TANH;
582 float clippingThresCell = 10.f;
583 float clippingThresProj = 0.f;
584 bool isTimeMajor = false;
585
586 UnidirectionalSequenceLstmTestImpl<float>(backends,
587 ::tflite::TensorType_FLOAT32,
588 batchSize,
589 timeSize,
590 inputSize,
591 outputSize,
592 numUnits,
593 hasInputToInputWeights,
594 inputToInputWeights,
595 inputToForgetWeights,
596 inputToCellWeights,
597 inputToOutputWeights,
598 hasRecurrentToInputWeights,
599 recurrentToInputWeights,
600 recurrentToForgetWeights,
601 recurrentToCellWeights,
602 recurrentToOutputWeights,
603 hasCellToInputWeights,
604 cellToInputWeights,
605 hasCellToForgetWeights,
606 cellToForgetWeights,
607 hasCellToOutputWeights,
608 cellToOutputWeights,
609 hasInputGateBias,
610 inputGateBias,
611 forgetGateBias,
612 cellBias,
613 outputGateBias,
614 hasProjectionWeights,
615 projectionWeights,
616 hasProjectionBias,
617 projectionBias,
618 hasInputLayerNormWeights,
619 inputLayerNormWeights,
620 hasForgetLayerNormWeights,
621 forgetLayerNormWeights,
622 hasCellLayerNormWeights,
623 cellLayerNormWeights,
624 hasOutputLayerNormWeights,
625 outputLayerNormWeights,
626 inputValues,
627 expectedOutputValues,
628 activationFunction,
629 clippingThresCell,
630 clippingThresProj,
631 isTimeMajor);
632}
633
634void UnidirectionalSequenceLstmNoCifgWithPeepholeWithProjectionWithLayerNormTest(
635 std::vector<armnn::BackendId>& backends)
636{
637 int32_t batchSize = 3;
638 int32_t timeSize = 2;
639 int32_t inputSize = 3;
640 int32_t outputSize = 4;
641 int32_t numUnits = 5;
642
643 //tensorInfo15
644 bool hasInputToInputWeights = true;
645 std::vector<float> inputToInputWeights = { -0.49536117f, -0.0556083915f, -0.102400711f,
646 -0.117484632f, 0.3298470976f, -0.1179017122f,
647 0.214305695f, 0.42135173085f, 0.003878414626f,
648 -0.348303917f, -0.1881275477f, 0.0343011027f,
649 -0.38837709614f, -0.05636804124f, 0.4259087456f};
650
651 std::vector<float> inputToForgetWeights = { 0.2415594226f, 0.15400093799f, 0.4566498398f,
652 -0.3810434485f, 0.268383264f, -0.009807467424f,
653 -0.3522925403f, -0.24275735512f, -0.28344226125f,
654 0.13512269116f, -0.4932442977f, -0.10039821991f,
655 0.2726137042f, 0.09216640889f, -0.06551410215f};
656
657 std::vector<float> inputToCellWeights = { -0.2504855627f, 0.184490025045f, -0.2480507493f,
658 0.386399507f, -0.259465157985f, -0.16545993089f,
659 -0.4230232555f, 0.341664791103f, -0.18127849691f,
660 -0.2277662414f, -0.55275535589f, 0.34184026718f,
661 0.3954237699f, -0.19407111404f, 0.30412107706f};
662
663 std::vector<float> inputToOutputWeights = { 0.2303854227f, 0.5218806862f, -0.4865379333f,
664 0.53969591851f, 0.23393625035f, -0.27140527306f,
665 0.50009280443f, 0.07511717046f, 0.3998299249f,
666 -0.51717478049f, 0.1889653282f, -0.367323637f,
667 -0.12584099173f, -0.12319286912f, 0.2407919466f};
668
669 //tensorInfo20
670 bool hasRecurrentToInputWeights = true;
671 std::vector<float> recurrentToInputWeights = { -0.128009796112f, 0.1995525098f, -0.07745539397f, 0.1558421701f,
672 -0.265254765766f, -0.38837709614f, -0.05636804124f, 0.4259087456f,
673 0.17628988623f, 0.3877420127f, 0.53300309181f, -0.0959980934f,
674 0.00302857416f, 0.3266998827f, -0.142509296562f, -0.04433270756f,
675 0.54066205f, -0.32668582f, -0.43562764f, -0.56094903f };
676
677 std::vector<float> recurrentToForgetWeights = { -0.09499983487f, -0.08814888417f, -0.04834804721f, 0.1516668247f,
678 -0.3967529535f, -0.06463699788f, 0.4952811002f, 0.003274492938f,
679 -0.0968840941f, 0.17928104102f, 0.0031281141592f, -0.3387276584f,
680 -0.3587934076f, 0.06705895066f, 0.22463923692f, 0.1961955726f,
681 0.01841056f, -0.32764608f, -0.33027974f, -0.10826075f };
682
683 std::vector<float> recurrentToCellWeights = { -0.21938985582f, -0.3023648226f, -0.1170005202f, -0.3509177422f,
684 -0.4286288613f, 0.2726137042f, 0.09216640889f, -0.06551410215f,
685 0.20453298098f, 0.2393476665f, 0.11846517771f, 0.2630801796f,
686 0.3954237699f, -0.19407111404f, 0.30412107706f, -0.27342408554f,
687 0.19069612f, -0.03026325f, -0.54532051f, 0.33003211f };
688
689 std::vector<float> recurrentToOutputWeights = { -0.32921677827f, 0.32624614238f, -0.1388191282f, -0.17879831790f,
690 -0.15185534954f, -0.16918526583f, -0.10087361183f, -0.5436913968f,
691 0.016758225858f, 0.30454617738f, -0.41493862867f, -0.005565764375f,
692 -0.12584099173f, -0.12319286912f, 0.2407919466f, -0.08879069983f,
693 0.11178309f, 0.09481031f, -0.26424935f, 0.46261835f };
694 // tensorInfo5
695 bool hasCellToInputWeights = true;
696 std::vector<float> cellToInputWeights = { 0.05f, 0.1f, 0.25f, 0.15f, -0.02f };
697 bool hasCellToForgetWeights = true;
698 std::vector<float> cellToForgetWeights = { -0.02f, -0.15f, -0.25f, -0.03f, 0.15f };
699 bool hasCellToOutputWeights = true;
700 std::vector<float> cellToOutputWeights = { 0.1f, -0.1f, -0.5f, 0.05f, 0.01f };
701
702 bool hasInputGateBias = true;
703 std::vector<float> inputGateBias = { 0.03f, 0.15f, 0.22f, 0.38f, 0.05f };
704 std::vector<float> forgetGateBias = { 0.1f, -0.3f, -0.2f, 0.1f, 0.4f };
705 std::vector<float> cellBias = { -0.05f, 0.72f, 0.25f, 0.08f, 0.1f };
706 std::vector<float> outputGateBias = { 0.05f, -0.01f, 0.2f, 0.1f, -0.2f };
707
708 bool hasProjectionWeights = true;
709 std::vector<float> projectionWeights = { -0.1f, 0.2f, 0.01f, -0.2f,
710 0.1f, 0.5f, 0.3f, 0.08f,
711 0.07f, 0.2f, -0.4f, 0.2f,
712 0.5f, -0.4f, 0.3f, -0.2f,
713 0.3f, 0.08f, -0.07f, 0.2f}; //{outputSize, numUnits}
714 bool hasProjectionBias = true;
715 std::vector<float> projectionBias(outputSize, 0.f);;
716
717 bool hasInputLayerNormWeights = true;
718 std::vector<float> inputLayerNormWeights = { 0.1f, 0.2f, 0.3f, 0.5f, 0.8f };
719 bool hasForgetLayerNormWeights = true;
720 std::vector<float> forgetLayerNormWeights = { 0.1f, 0.2f, 0.3f, 0.5f, 0.2f };
721 bool hasCellLayerNormWeights = true;
722 std::vector<float> cellLayerNormWeights = { 0.7f, 0.2f, 0.3f, 0.8f, 0.5f };
723 bool hasOutputLayerNormWeights = true;
724 std::vector<float> outputLayerNormWeights = { 0.6f, 0.2f, 0.2f, 0.5f, 0.1f };
725
726 std::vector<float> inputValues = { 1., 2., 3., 4., 5., 4.,
727 3., 2., 1., 2., 3., 4.,
728 5., 4., 3., 2., 1., 2. };
729 std::vector<float> expectedOutputValues = { 0.0642256f, 0.0343966f, 0.184122f, 0.114717f,
730 0.11458f, 0.0407109f, 0.300327f, 0.174301f,
731 0.0864761f, 0.0362912f, 0.178635f, 0.115689f,
732 0.108008f, 0.0386623f, 0.273471f, 0.167115f,
733 0.0859545f, 0.0331481f, 0.186051f, 0.11888f,
734 0.106649f, 0.0276847f, 0.229863f, 0.166958f };
735
736 tflite::ActivationFunctionType activationFunction = tflite::ActivationFunctionType_TANH;
737 float clippingThresCell = 10.f;
738 float clippingThresProj = 0.f;
739 bool isTimeMajor = false;
740
741 UnidirectionalSequenceLstmTestImpl<float>(backends,
742 ::tflite::TensorType_FLOAT32,
743 batchSize,
744 timeSize,
745 inputSize,
746 outputSize,
747 numUnits,
748 hasInputToInputWeights,
749 inputToInputWeights,
750 inputToForgetWeights,
751 inputToCellWeights,
752 inputToOutputWeights,
753 hasRecurrentToInputWeights,
754 recurrentToInputWeights,
755 recurrentToForgetWeights,
756 recurrentToCellWeights,
757 recurrentToOutputWeights,
758 hasCellToInputWeights,
759 cellToInputWeights,
760 hasCellToForgetWeights,
761 cellToForgetWeights,
762 hasCellToOutputWeights,
763 cellToOutputWeights,
764 hasInputGateBias,
765 inputGateBias,
766 forgetGateBias,
767 cellBias,
768 outputGateBias,
769 hasProjectionWeights,
770 projectionWeights,
771 hasProjectionBias,
772 projectionBias,
773 hasInputLayerNormWeights,
774 inputLayerNormWeights,
775 hasForgetLayerNormWeights,
776 forgetLayerNormWeights,
777 hasCellLayerNormWeights,
778 cellLayerNormWeights,
779 hasOutputLayerNormWeights,
780 outputLayerNormWeights,
781 inputValues,
782 expectedOutputValues,
783 activationFunction,
784 clippingThresCell,
785 clippingThresProj,
786 isTimeMajor);
787}
788
789
790
791TEST_SUITE("UnidirectionalSequenceLstmTest_CpuRefTests")
792{
793
794TEST_CASE ("UnidirectionalSequenceLstmTest_CpuRef_Test")
795{
796 std::vector <armnn::BackendId> backends = {armnn::Compute::CpuRef};
797 UnidirectionalSequenceLstmTest(backends);
798}
799
800TEST_CASE ("UnidirectionalSequenceLstmTimeMajorTest_CpuRef_Test")
801{
802 std::vector <armnn::BackendId> backends = {armnn::Compute::CpuRef};
803 UnidirectionalSequenceLstmTimeMajorTest(backends);
804}
805
806TEST_CASE ("UnidirectionalSequenceLstmNoCifgWithPeepholeWithProjectionTest_CpuRef_Test")
807{
808 std::vector <armnn::BackendId> backends = {armnn::Compute::CpuRef};
809 UnidirectionalSequenceLstmNoCifgWithPeepholeWithProjectionTest(backends);
810}
811
812TEST_CASE ("UnidirectionalSequenceLstmWithCifgWithPeepholeNoProjectionTest_CpuRef_Test")
813{
814 std::vector <armnn::BackendId> backends = {armnn::Compute::CpuRef};
815 UnidirectionalSequenceLstmWithCifgWithPeepholeNoProjectionTest(backends);
816}
817
818TEST_CASE ("UnidirectionalSequenceLstmNoCifgWithPeepholeWithProjectionWithLayerNormTest_CpuRef_Test")
819{
820 std::vector <armnn::BackendId> backends = {armnn::Compute::CpuRef};
821 UnidirectionalSequenceLstmNoCifgWithPeepholeWithProjectionWithLayerNormTest(backends);
822}
823
824} //End of TEST_SUITE("UnidirectionalSequenceLstmTest_CpuRef")
825
826} // namespace armnnDelegate