1 // Generated from prelu.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper;
6
7 namespace generated_tests::prelu {
8
get_test_model()9 const TestModel& get_test_model() {
10 static TestModel model = {
11 .expectFailure = false,
12 .expectedMultinomialDistributionTolerance = 0,
13 .isRelaxed = false,
14 .main = {
15 .inputIndexes = {0},
16 .operands = {{ // input
17 .channelQuant = {},
18 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
19 .dimensions = {1, 2, 2, 3},
20 .isIgnored = false,
21 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22 .numberOfConsumers = 1,
23 .scale = 0.0f,
24 .type = TestOperandType::TENSOR_FLOAT32,
25 .zeroPoint = 0
26 }, { // alpha
27 .channelQuant = {},
28 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
29 .dimensions = {1, 1, 3},
30 .isIgnored = false,
31 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
32 .numberOfConsumers = 1,
33 .scale = 0.0f,
34 .type = TestOperandType::TENSOR_FLOAT32,
35 .zeroPoint = 0
36 }, { // output
37 .channelQuant = {},
38 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
39 .dimensions = {1, 2, 2, 3},
40 .isIgnored = false,
41 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
42 .numberOfConsumers = 0,
43 .scale = 0.0f,
44 .type = TestOperandType::TENSOR_FLOAT32,
45 .zeroPoint = 0
46 }},
47 .operations = {{
48 .inputs = {0, 1},
49 .outputs = {2},
50 .type = TestOperationType::PRELU
51 }},
52 .outputIndexes = {2}
53 },
54 .minSupportedVersion = TestHalVersion::V1_2,
55 .referenced = {}
56 };
57 return model;
58 }
59
60 const auto dummy_test_model = TestModelManager::get().add("prelu", get_test_model());
61
62 } // namespace generated_tests::prelu
63
64 namespace generated_tests::prelu {
65
get_test_model_all_inputs_as_internal()66 const TestModel& get_test_model_all_inputs_as_internal() {
67 static TestModel model = {
68 .expectFailure = false,
69 .expectedMultinomialDistributionTolerance = 0,
70 .isRelaxed = false,
71 .main = {
72 .inputIndexes = {3},
73 .operands = {{ // input
74 .channelQuant = {},
75 .data = TestBuffer::createFromVector<float>({}),
76 .dimensions = {1, 2, 2, 3},
77 .isIgnored = false,
78 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
79 .numberOfConsumers = 1,
80 .scale = 0.0f,
81 .type = TestOperandType::TENSOR_FLOAT32,
82 .zeroPoint = 0
83 }, { // alpha
84 .channelQuant = {},
85 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
86 .dimensions = {1, 1, 3},
87 .isIgnored = false,
88 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
89 .numberOfConsumers = 1,
90 .scale = 0.0f,
91 .type = TestOperandType::TENSOR_FLOAT32,
92 .zeroPoint = 0
93 }, { // output
94 .channelQuant = {},
95 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
96 .dimensions = {1, 2, 2, 3},
97 .isIgnored = false,
98 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
99 .numberOfConsumers = 0,
100 .scale = 0.0f,
101 .type = TestOperandType::TENSOR_FLOAT32,
102 .zeroPoint = 0
103 }, { // input_new
104 .channelQuant = {},
105 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
106 .dimensions = {1, 2, 2, 3},
107 .isIgnored = false,
108 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
109 .numberOfConsumers = 1,
110 .scale = 0.0f,
111 .type = TestOperandType::TENSOR_FLOAT32,
112 .zeroPoint = 0
113 }, { // placeholder
114 .channelQuant = {},
115 .data = TestBuffer::createFromVector<float>({0.0f}),
116 .dimensions = {1},
117 .isIgnored = false,
118 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
119 .numberOfConsumers = 1,
120 .scale = 0.0f,
121 .type = TestOperandType::TENSOR_FLOAT32,
122 .zeroPoint = 0
123 }, { // param
124 .channelQuant = {},
125 .data = TestBuffer::createFromVector<int32_t>({0}),
126 .dimensions = {},
127 .isIgnored = false,
128 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
129 .numberOfConsumers = 1,
130 .scale = 0.0f,
131 .type = TestOperandType::INT32,
132 .zeroPoint = 0
133 }},
134 .operations = {{
135 .inputs = {3, 4, 5},
136 .outputs = {0},
137 .type = TestOperationType::ADD
138 }, {
139 .inputs = {0, 1},
140 .outputs = {2},
141 .type = TestOperationType::PRELU
142 }},
143 .outputIndexes = {2}
144 },
145 .minSupportedVersion = TestHalVersion::V1_2,
146 .referenced = {}
147 };
148 return model;
149 }
150
151 const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("prelu_all_inputs_as_internal", get_test_model_all_inputs_as_internal());
152
153 } // namespace generated_tests::prelu
154
155 namespace generated_tests::prelu {
156
get_test_model_all_tensors_as_inputs()157 const TestModel& get_test_model_all_tensors_as_inputs() {
158 static TestModel model = {
159 .expectFailure = false,
160 .expectedMultinomialDistributionTolerance = 0,
161 .isRelaxed = false,
162 .main = {
163 .inputIndexes = {0, 1},
164 .operands = {{ // input
165 .channelQuant = {},
166 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
167 .dimensions = {1, 2, 2, 3},
168 .isIgnored = false,
169 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
170 .numberOfConsumers = 1,
171 .scale = 0.0f,
172 .type = TestOperandType::TENSOR_FLOAT32,
173 .zeroPoint = 0
174 }, { // alpha
175 .channelQuant = {},
176 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
177 .dimensions = {1, 1, 3},
178 .isIgnored = false,
179 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
180 .numberOfConsumers = 1,
181 .scale = 0.0f,
182 .type = TestOperandType::TENSOR_FLOAT32,
183 .zeroPoint = 0
184 }, { // output
185 .channelQuant = {},
186 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
187 .dimensions = {1, 2, 2, 3},
188 .isIgnored = false,
189 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
190 .numberOfConsumers = 0,
191 .scale = 0.0f,
192 .type = TestOperandType::TENSOR_FLOAT32,
193 .zeroPoint = 0
194 }},
195 .operations = {{
196 .inputs = {0, 1},
197 .outputs = {2},
198 .type = TestOperationType::PRELU
199 }},
200 .outputIndexes = {2}
201 },
202 .minSupportedVersion = TestHalVersion::V1_2,
203 .referenced = {}
204 };
205 return model;
206 }
207
208 const auto dummy_test_model_all_tensors_as_inputs = TestModelManager::get().add("prelu_all_tensors_as_inputs", get_test_model_all_tensors_as_inputs());
209
210 } // namespace generated_tests::prelu
211
212 namespace generated_tests::prelu {
213
get_test_model_all_tensors_as_inputs_all_inputs_as_internal()214 const TestModel& get_test_model_all_tensors_as_inputs_all_inputs_as_internal() {
215 static TestModel model = {
216 .expectFailure = false,
217 .expectedMultinomialDistributionTolerance = 0,
218 .isRelaxed = false,
219 .main = {
220 .inputIndexes = {3, 6},
221 .operands = {{ // input
222 .channelQuant = {},
223 .data = TestBuffer::createFromVector<float>({}),
224 .dimensions = {1, 2, 2, 3},
225 .isIgnored = false,
226 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
227 .numberOfConsumers = 1,
228 .scale = 0.0f,
229 .type = TestOperandType::TENSOR_FLOAT32,
230 .zeroPoint = 0
231 }, { // alpha
232 .channelQuant = {},
233 .data = TestBuffer::createFromVector<float>({}),
234 .dimensions = {1, 1, 3},
235 .isIgnored = false,
236 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
237 .numberOfConsumers = 1,
238 .scale = 0.0f,
239 .type = TestOperandType::TENSOR_FLOAT32,
240 .zeroPoint = 0
241 }, { // output
242 .channelQuant = {},
243 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
244 .dimensions = {1, 2, 2, 3},
245 .isIgnored = false,
246 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
247 .numberOfConsumers = 0,
248 .scale = 0.0f,
249 .type = TestOperandType::TENSOR_FLOAT32,
250 .zeroPoint = 0
251 }, { // input_new
252 .channelQuant = {},
253 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
254 .dimensions = {1, 2, 2, 3},
255 .isIgnored = false,
256 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
257 .numberOfConsumers = 1,
258 .scale = 0.0f,
259 .type = TestOperandType::TENSOR_FLOAT32,
260 .zeroPoint = 0
261 }, { // placeholder1
262 .channelQuant = {},
263 .data = TestBuffer::createFromVector<float>({0.0f}),
264 .dimensions = {1},
265 .isIgnored = false,
266 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
267 .numberOfConsumers = 1,
268 .scale = 0.0f,
269 .type = TestOperandType::TENSOR_FLOAT32,
270 .zeroPoint = 0
271 }, { // param1
272 .channelQuant = {},
273 .data = TestBuffer::createFromVector<int32_t>({0}),
274 .dimensions = {},
275 .isIgnored = false,
276 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
277 .numberOfConsumers = 1,
278 .scale = 0.0f,
279 .type = TestOperandType::INT32,
280 .zeroPoint = 0
281 }, { // alpha_new
282 .channelQuant = {},
283 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
284 .dimensions = {1, 1, 3},
285 .isIgnored = false,
286 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
287 .numberOfConsumers = 1,
288 .scale = 0.0f,
289 .type = TestOperandType::TENSOR_FLOAT32,
290 .zeroPoint = 0
291 }, { // placeholder2
292 .channelQuant = {},
293 .data = TestBuffer::createFromVector<float>({0.0f}),
294 .dimensions = {1},
295 .isIgnored = false,
296 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
297 .numberOfConsumers = 1,
298 .scale = 0.0f,
299 .type = TestOperandType::TENSOR_FLOAT32,
300 .zeroPoint = 0
301 }, { // param2
302 .channelQuant = {},
303 .data = TestBuffer::createFromVector<int32_t>({0}),
304 .dimensions = {},
305 .isIgnored = false,
306 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
307 .numberOfConsumers = 1,
308 .scale = 0.0f,
309 .type = TestOperandType::INT32,
310 .zeroPoint = 0
311 }},
312 .operations = {{
313 .inputs = {3, 4, 5},
314 .outputs = {0},
315 .type = TestOperationType::ADD
316 }, {
317 .inputs = {6, 7, 8},
318 .outputs = {1},
319 .type = TestOperationType::ADD
320 }, {
321 .inputs = {0, 1},
322 .outputs = {2},
323 .type = TestOperationType::PRELU
324 }},
325 .outputIndexes = {2}
326 },
327 .minSupportedVersion = TestHalVersion::V1_2,
328 .referenced = {}
329 };
330 return model;
331 }
332
333 const auto dummy_test_model_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("prelu_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_all_tensors_as_inputs_all_inputs_as_internal());
334
335 } // namespace generated_tests::prelu
336
337 namespace generated_tests::prelu {
338
get_test_model_relaxed()339 const TestModel& get_test_model_relaxed() {
340 static TestModel model = {
341 .expectFailure = false,
342 .expectedMultinomialDistributionTolerance = 0,
343 .isRelaxed = true,
344 .main = {
345 .inputIndexes = {0},
346 .operands = {{ // input
347 .channelQuant = {},
348 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
349 .dimensions = {1, 2, 2, 3},
350 .isIgnored = false,
351 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
352 .numberOfConsumers = 1,
353 .scale = 0.0f,
354 .type = TestOperandType::TENSOR_FLOAT32,
355 .zeroPoint = 0
356 }, { // alpha
357 .channelQuant = {},
358 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
359 .dimensions = {1, 1, 3},
360 .isIgnored = false,
361 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
362 .numberOfConsumers = 1,
363 .scale = 0.0f,
364 .type = TestOperandType::TENSOR_FLOAT32,
365 .zeroPoint = 0
366 }, { // output
367 .channelQuant = {},
368 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
369 .dimensions = {1, 2, 2, 3},
370 .isIgnored = false,
371 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
372 .numberOfConsumers = 0,
373 .scale = 0.0f,
374 .type = TestOperandType::TENSOR_FLOAT32,
375 .zeroPoint = 0
376 }},
377 .operations = {{
378 .inputs = {0, 1},
379 .outputs = {2},
380 .type = TestOperationType::PRELU
381 }},
382 .outputIndexes = {2}
383 },
384 .minSupportedVersion = TestHalVersion::UNKNOWN,
385 .referenced = {}
386 };
387 return model;
388 }
389
390 const auto dummy_test_model_relaxed = TestModelManager::get().add("prelu_relaxed", get_test_model_relaxed());
391
392 } // namespace generated_tests::prelu
393
394 namespace generated_tests::prelu {
395
get_test_model_relaxed_all_inputs_as_internal()396 const TestModel& get_test_model_relaxed_all_inputs_as_internal() {
397 static TestModel model = {
398 .expectFailure = false,
399 .expectedMultinomialDistributionTolerance = 0,
400 .isRelaxed = true,
401 .main = {
402 .inputIndexes = {3},
403 .operands = {{ // input
404 .channelQuant = {},
405 .data = TestBuffer::createFromVector<float>({}),
406 .dimensions = {1, 2, 2, 3},
407 .isIgnored = false,
408 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
409 .numberOfConsumers = 1,
410 .scale = 0.0f,
411 .type = TestOperandType::TENSOR_FLOAT32,
412 .zeroPoint = 0
413 }, { // alpha
414 .channelQuant = {},
415 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
416 .dimensions = {1, 1, 3},
417 .isIgnored = false,
418 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
419 .numberOfConsumers = 1,
420 .scale = 0.0f,
421 .type = TestOperandType::TENSOR_FLOAT32,
422 .zeroPoint = 0
423 }, { // output
424 .channelQuant = {},
425 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
426 .dimensions = {1, 2, 2, 3},
427 .isIgnored = false,
428 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
429 .numberOfConsumers = 0,
430 .scale = 0.0f,
431 .type = TestOperandType::TENSOR_FLOAT32,
432 .zeroPoint = 0
433 }, { // input_new
434 .channelQuant = {},
435 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
436 .dimensions = {1, 2, 2, 3},
437 .isIgnored = false,
438 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
439 .numberOfConsumers = 1,
440 .scale = 0.0f,
441 .type = TestOperandType::TENSOR_FLOAT32,
442 .zeroPoint = 0
443 }, { // placeholder3
444 .channelQuant = {},
445 .data = TestBuffer::createFromVector<float>({0.0f}),
446 .dimensions = {1},
447 .isIgnored = false,
448 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
449 .numberOfConsumers = 1,
450 .scale = 0.0f,
451 .type = TestOperandType::TENSOR_FLOAT32,
452 .zeroPoint = 0
453 }, { // param3
454 .channelQuant = {},
455 .data = TestBuffer::createFromVector<int32_t>({0}),
456 .dimensions = {},
457 .isIgnored = false,
458 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
459 .numberOfConsumers = 1,
460 .scale = 0.0f,
461 .type = TestOperandType::INT32,
462 .zeroPoint = 0
463 }},
464 .operations = {{
465 .inputs = {3, 4, 5},
466 .outputs = {0},
467 .type = TestOperationType::ADD
468 }, {
469 .inputs = {0, 1},
470 .outputs = {2},
471 .type = TestOperationType::PRELU
472 }},
473 .outputIndexes = {2}
474 },
475 .minSupportedVersion = TestHalVersion::UNKNOWN,
476 .referenced = {}
477 };
478 return model;
479 }
480
481 const auto dummy_test_model_relaxed_all_inputs_as_internal = TestModelManager::get().add("prelu_relaxed_all_inputs_as_internal", get_test_model_relaxed_all_inputs_as_internal());
482
483 } // namespace generated_tests::prelu
484
485 namespace generated_tests::prelu {
486
get_test_model_relaxed_all_tensors_as_inputs()487 const TestModel& get_test_model_relaxed_all_tensors_as_inputs() {
488 static TestModel model = {
489 .expectFailure = false,
490 .expectedMultinomialDistributionTolerance = 0,
491 .isRelaxed = true,
492 .main = {
493 .inputIndexes = {0, 1},
494 .operands = {{ // input
495 .channelQuant = {},
496 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
497 .dimensions = {1, 2, 2, 3},
498 .isIgnored = false,
499 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
500 .numberOfConsumers = 1,
501 .scale = 0.0f,
502 .type = TestOperandType::TENSOR_FLOAT32,
503 .zeroPoint = 0
504 }, { // alpha
505 .channelQuant = {},
506 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
507 .dimensions = {1, 1, 3},
508 .isIgnored = false,
509 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
510 .numberOfConsumers = 1,
511 .scale = 0.0f,
512 .type = TestOperandType::TENSOR_FLOAT32,
513 .zeroPoint = 0
514 }, { // output
515 .channelQuant = {},
516 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
517 .dimensions = {1, 2, 2, 3},
518 .isIgnored = false,
519 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
520 .numberOfConsumers = 0,
521 .scale = 0.0f,
522 .type = TestOperandType::TENSOR_FLOAT32,
523 .zeroPoint = 0
524 }},
525 .operations = {{
526 .inputs = {0, 1},
527 .outputs = {2},
528 .type = TestOperationType::PRELU
529 }},
530 .outputIndexes = {2}
531 },
532 .minSupportedVersion = TestHalVersion::UNKNOWN,
533 .referenced = {}
534 };
535 return model;
536 }
537
538 const auto dummy_test_model_relaxed_all_tensors_as_inputs = TestModelManager::get().add("prelu_relaxed_all_tensors_as_inputs", get_test_model_relaxed_all_tensors_as_inputs());
539
540 } // namespace generated_tests::prelu
541
542 namespace generated_tests::prelu {
543
get_test_model_relaxed_all_tensors_as_inputs_all_inputs_as_internal()544 const TestModel& get_test_model_relaxed_all_tensors_as_inputs_all_inputs_as_internal() {
545 static TestModel model = {
546 .expectFailure = false,
547 .expectedMultinomialDistributionTolerance = 0,
548 .isRelaxed = true,
549 .main = {
550 .inputIndexes = {3, 6},
551 .operands = {{ // input
552 .channelQuant = {},
553 .data = TestBuffer::createFromVector<float>({}),
554 .dimensions = {1, 2, 2, 3},
555 .isIgnored = false,
556 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
557 .numberOfConsumers = 1,
558 .scale = 0.0f,
559 .type = TestOperandType::TENSOR_FLOAT32,
560 .zeroPoint = 0
561 }, { // alpha
562 .channelQuant = {},
563 .data = TestBuffer::createFromVector<float>({}),
564 .dimensions = {1, 1, 3},
565 .isIgnored = false,
566 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
567 .numberOfConsumers = 1,
568 .scale = 0.0f,
569 .type = TestOperandType::TENSOR_FLOAT32,
570 .zeroPoint = 0
571 }, { // output
572 .channelQuant = {},
573 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
574 .dimensions = {1, 2, 2, 3},
575 .isIgnored = false,
576 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
577 .numberOfConsumers = 0,
578 .scale = 0.0f,
579 .type = TestOperandType::TENSOR_FLOAT32,
580 .zeroPoint = 0
581 }, { // input_new
582 .channelQuant = {},
583 .data = TestBuffer::createFromVector<float>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
584 .dimensions = {1, 2, 2, 3},
585 .isIgnored = false,
586 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
587 .numberOfConsumers = 1,
588 .scale = 0.0f,
589 .type = TestOperandType::TENSOR_FLOAT32,
590 .zeroPoint = 0
591 }, { // placeholder4
592 .channelQuant = {},
593 .data = TestBuffer::createFromVector<float>({0.0f}),
594 .dimensions = {1},
595 .isIgnored = false,
596 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
597 .numberOfConsumers = 1,
598 .scale = 0.0f,
599 .type = TestOperandType::TENSOR_FLOAT32,
600 .zeroPoint = 0
601 }, { // param4
602 .channelQuant = {},
603 .data = TestBuffer::createFromVector<int32_t>({0}),
604 .dimensions = {},
605 .isIgnored = false,
606 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
607 .numberOfConsumers = 1,
608 .scale = 0.0f,
609 .type = TestOperandType::INT32,
610 .zeroPoint = 0
611 }, { // alpha_new
612 .channelQuant = {},
613 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f}),
614 .dimensions = {1, 1, 3},
615 .isIgnored = false,
616 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
617 .numberOfConsumers = 1,
618 .scale = 0.0f,
619 .type = TestOperandType::TENSOR_FLOAT32,
620 .zeroPoint = 0
621 }, { // placeholder5
622 .channelQuant = {},
623 .data = TestBuffer::createFromVector<float>({0.0f}),
624 .dimensions = {1},
625 .isIgnored = false,
626 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
627 .numberOfConsumers = 1,
628 .scale = 0.0f,
629 .type = TestOperandType::TENSOR_FLOAT32,
630 .zeroPoint = 0
631 }, { // param5
632 .channelQuant = {},
633 .data = TestBuffer::createFromVector<int32_t>({0}),
634 .dimensions = {},
635 .isIgnored = false,
636 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
637 .numberOfConsumers = 1,
638 .scale = 0.0f,
639 .type = TestOperandType::INT32,
640 .zeroPoint = 0
641 }},
642 .operations = {{
643 .inputs = {3, 4, 5},
644 .outputs = {0},
645 .type = TestOperationType::ADD
646 }, {
647 .inputs = {6, 7, 8},
648 .outputs = {1},
649 .type = TestOperationType::ADD
650 }, {
651 .inputs = {0, 1},
652 .outputs = {2},
653 .type = TestOperationType::PRELU
654 }},
655 .outputIndexes = {2}
656 },
657 .minSupportedVersion = TestHalVersion::UNKNOWN,
658 .referenced = {}
659 };
660 return model;
661 }
662
663 const auto dummy_test_model_relaxed_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("prelu_relaxed_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_relaxed_all_tensors_as_inputs_all_inputs_as_internal());
664
665 } // namespace generated_tests::prelu
666
667 namespace generated_tests::prelu {
668
get_test_model_quant8()669 const TestModel& get_test_model_quant8() {
670 static TestModel model = {
671 .expectFailure = false,
672 .expectedMultinomialDistributionTolerance = 0,
673 .isRelaxed = false,
674 .main = {
675 .inputIndexes = {0},
676 .operands = {{ // input
677 .channelQuant = {},
678 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
679 .dimensions = {1, 2, 2, 3},
680 .isIgnored = false,
681 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
682 .numberOfConsumers = 1,
683 .scale = 0.25f,
684 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
685 .zeroPoint = 128
686 }, { // alpha
687 .channelQuant = {},
688 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
689 .dimensions = {1, 1, 3},
690 .isIgnored = false,
691 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
692 .numberOfConsumers = 1,
693 .scale = 0.25f,
694 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
695 .zeroPoint = 50
696 }, { // output
697 .channelQuant = {},
698 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 122, 122, 122, 120, 118, 116, 120, 116, 112}),
699 .dimensions = {1, 2, 2, 3},
700 .isIgnored = false,
701 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
702 .numberOfConsumers = 0,
703 .scale = 0.5f,
704 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
705 .zeroPoint = 120
706 }},
707 .operations = {{
708 .inputs = {0, 1},
709 .outputs = {2},
710 .type = TestOperationType::PRELU
711 }},
712 .outputIndexes = {2}
713 },
714 .minSupportedVersion = TestHalVersion::V1_2,
715 .referenced = {}
716 };
717 return model;
718 }
719
720 const auto dummy_test_model_quant8 = TestModelManager::get().add("prelu_quant8", get_test_model_quant8());
721
722 } // namespace generated_tests::prelu
723
724 namespace generated_tests::prelu {
725
get_test_model_quant8_all_inputs_as_internal()726 const TestModel& get_test_model_quant8_all_inputs_as_internal() {
727 static TestModel model = {
728 .expectFailure = false,
729 .expectedMultinomialDistributionTolerance = 0,
730 .isRelaxed = false,
731 .main = {
732 .inputIndexes = {3},
733 .operands = {{ // input
734 .channelQuant = {},
735 .data = TestBuffer::createFromVector<uint8_t>({}),
736 .dimensions = {1, 2, 2, 3},
737 .isIgnored = false,
738 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
739 .numberOfConsumers = 1,
740 .scale = 0.25f,
741 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
742 .zeroPoint = 128
743 }, { // alpha
744 .channelQuant = {},
745 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
746 .dimensions = {1, 1, 3},
747 .isIgnored = false,
748 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
749 .numberOfConsumers = 1,
750 .scale = 0.25f,
751 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
752 .zeroPoint = 50
753 }, { // output
754 .channelQuant = {},
755 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 122, 122, 122, 120, 118, 116, 120, 116, 112}),
756 .dimensions = {1, 2, 2, 3},
757 .isIgnored = false,
758 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
759 .numberOfConsumers = 0,
760 .scale = 0.5f,
761 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
762 .zeroPoint = 120
763 }, { // input_new
764 .channelQuant = {},
765 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
766 .dimensions = {1, 2, 2, 3},
767 .isIgnored = false,
768 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
769 .numberOfConsumers = 1,
770 .scale = 0.25f,
771 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
772 .zeroPoint = 128
773 }, { // placeholder6
774 .channelQuant = {},
775 .data = TestBuffer::createFromVector<uint8_t>({128}),
776 .dimensions = {1},
777 .isIgnored = false,
778 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
779 .numberOfConsumers = 1,
780 .scale = 0.25f,
781 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
782 .zeroPoint = 128
783 }, { // param6
784 .channelQuant = {},
785 .data = TestBuffer::createFromVector<int32_t>({0}),
786 .dimensions = {},
787 .isIgnored = false,
788 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
789 .numberOfConsumers = 1,
790 .scale = 0.0f,
791 .type = TestOperandType::INT32,
792 .zeroPoint = 0
793 }},
794 .operations = {{
795 .inputs = {3, 4, 5},
796 .outputs = {0},
797 .type = TestOperationType::ADD
798 }, {
799 .inputs = {0, 1},
800 .outputs = {2},
801 .type = TestOperationType::PRELU
802 }},
803 .outputIndexes = {2}
804 },
805 .minSupportedVersion = TestHalVersion::V1_2,
806 .referenced = {}
807 };
808 return model;
809 }
810
811 const auto dummy_test_model_quant8_all_inputs_as_internal = TestModelManager::get().add("prelu_quant8_all_inputs_as_internal", get_test_model_quant8_all_inputs_as_internal());
812
813 } // namespace generated_tests::prelu
814
815 namespace generated_tests::prelu {
816
get_test_model_quant8_all_tensors_as_inputs()817 const TestModel& get_test_model_quant8_all_tensors_as_inputs() {
818 static TestModel model = {
819 .expectFailure = false,
820 .expectedMultinomialDistributionTolerance = 0,
821 .isRelaxed = false,
822 .main = {
823 .inputIndexes = {0, 1},
824 .operands = {{ // input
825 .channelQuant = {},
826 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
827 .dimensions = {1, 2, 2, 3},
828 .isIgnored = false,
829 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
830 .numberOfConsumers = 1,
831 .scale = 0.25f,
832 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
833 .zeroPoint = 128
834 }, { // alpha
835 .channelQuant = {},
836 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
837 .dimensions = {1, 1, 3},
838 .isIgnored = false,
839 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
840 .numberOfConsumers = 1,
841 .scale = 0.25f,
842 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
843 .zeroPoint = 50
844 }, { // output
845 .channelQuant = {},
846 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 122, 122, 122, 120, 118, 116, 120, 116, 112}),
847 .dimensions = {1, 2, 2, 3},
848 .isIgnored = false,
849 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
850 .numberOfConsumers = 0,
851 .scale = 0.5f,
852 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
853 .zeroPoint = 120
854 }},
855 .operations = {{
856 .inputs = {0, 1},
857 .outputs = {2},
858 .type = TestOperationType::PRELU
859 }},
860 .outputIndexes = {2}
861 },
862 .minSupportedVersion = TestHalVersion::V1_2,
863 .referenced = {}
864 };
865 return model;
866 }
867
868 const auto dummy_test_model_quant8_all_tensors_as_inputs = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs", get_test_model_quant8_all_tensors_as_inputs());
869
870 } // namespace generated_tests::prelu
871
872 namespace generated_tests::prelu {
873
get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal()874 const TestModel& get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal() {
875 static TestModel model = {
876 .expectFailure = false,
877 .expectedMultinomialDistributionTolerance = 0,
878 .isRelaxed = false,
879 .main = {
880 .inputIndexes = {3, 6},
881 .operands = {{ // input
882 .channelQuant = {},
883 .data = TestBuffer::createFromVector<uint8_t>({}),
884 .dimensions = {1, 2, 2, 3},
885 .isIgnored = false,
886 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
887 .numberOfConsumers = 1,
888 .scale = 0.25f,
889 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
890 .zeroPoint = 128
891 }, { // alpha
892 .channelQuant = {},
893 .data = TestBuffer::createFromVector<uint8_t>({}),
894 .dimensions = {1, 1, 3},
895 .isIgnored = false,
896 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
897 .numberOfConsumers = 1,
898 .scale = 0.25f,
899 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
900 .zeroPoint = 50
901 }, { // output
902 .channelQuant = {},
903 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 122, 122, 122, 120, 118, 116, 120, 116, 112}),
904 .dimensions = {1, 2, 2, 3},
905 .isIgnored = false,
906 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
907 .numberOfConsumers = 0,
908 .scale = 0.5f,
909 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
910 .zeroPoint = 120
911 }, { // input_new
912 .channelQuant = {},
913 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
914 .dimensions = {1, 2, 2, 3},
915 .isIgnored = false,
916 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
917 .numberOfConsumers = 1,
918 .scale = 0.25f,
919 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
920 .zeroPoint = 128
921 }, { // placeholder7
922 .channelQuant = {},
923 .data = TestBuffer::createFromVector<uint8_t>({128}),
924 .dimensions = {1},
925 .isIgnored = false,
926 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
927 .numberOfConsumers = 1,
928 .scale = 0.25f,
929 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
930 .zeroPoint = 128
931 }, { // param7
932 .channelQuant = {},
933 .data = TestBuffer::createFromVector<int32_t>({0}),
934 .dimensions = {},
935 .isIgnored = false,
936 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
937 .numberOfConsumers = 1,
938 .scale = 0.0f,
939 .type = TestOperandType::INT32,
940 .zeroPoint = 0
941 }, { // alpha_new
942 .channelQuant = {},
943 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
944 .dimensions = {1, 1, 3},
945 .isIgnored = false,
946 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
947 .numberOfConsumers = 1,
948 .scale = 0.25f,
949 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
950 .zeroPoint = 50
951 }, { // placeholder8
952 .channelQuant = {},
953 .data = TestBuffer::createFromVector<uint8_t>({50}),
954 .dimensions = {1},
955 .isIgnored = false,
956 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
957 .numberOfConsumers = 1,
958 .scale = 0.25f,
959 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
960 .zeroPoint = 50
961 }, { // param8
962 .channelQuant = {},
963 .data = TestBuffer::createFromVector<int32_t>({0}),
964 .dimensions = {},
965 .isIgnored = false,
966 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
967 .numberOfConsumers = 1,
968 .scale = 0.0f,
969 .type = TestOperandType::INT32,
970 .zeroPoint = 0
971 }},
972 .operations = {{
973 .inputs = {3, 4, 5},
974 .outputs = {0},
975 .type = TestOperationType::ADD
976 }, {
977 .inputs = {6, 7, 8},
978 .outputs = {1},
979 .type = TestOperationType::ADD
980 }, {
981 .inputs = {0, 1},
982 .outputs = {2},
983 .type = TestOperationType::PRELU
984 }},
985 .outputIndexes = {2}
986 },
987 .minSupportedVersion = TestHalVersion::V1_2,
988 .referenced = {}
989 };
990 return model;
991 }
992
993 const auto dummy_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal());
994
995 } // namespace generated_tests::prelu
996
997 namespace generated_tests::prelu {
998
get_test_model_quant8_2()999 const TestModel& get_test_model_quant8_2() {
1000 static TestModel model = {
1001 .expectFailure = false,
1002 .expectedMultinomialDistributionTolerance = 0,
1003 .isRelaxed = false,
1004 .main = {
1005 .inputIndexes = {0},
1006 .operands = {{ // input
1007 .channelQuant = {},
1008 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1009 .dimensions = {1, 2, 2, 3},
1010 .isIgnored = false,
1011 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1012 .numberOfConsumers = 1,
1013 .scale = 0.25f,
1014 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1015 .zeroPoint = 128
1016 }, { // alpha
1017 .channelQuant = {},
1018 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
1019 .dimensions = {1, 1, 3},
1020 .isIgnored = false,
1021 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1022 .numberOfConsumers = 1,
1023 .scale = 0.25f,
1024 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1025 .zeroPoint = 50
1026 }, { // output
1027 .channelQuant = {},
1028 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 124, 124, 124, 120, 116, 112, 120, 112, 104}),
1029 .dimensions = {1, 2, 2, 3},
1030 .isIgnored = false,
1031 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1032 .numberOfConsumers = 0,
1033 .scale = 0.25f,
1034 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1035 .zeroPoint = 120
1036 }},
1037 .operations = {{
1038 .inputs = {0, 1},
1039 .outputs = {2},
1040 .type = TestOperationType::PRELU
1041 }},
1042 .outputIndexes = {2}
1043 },
1044 .minSupportedVersion = TestHalVersion::V1_2,
1045 .referenced = {}
1046 };
1047 return model;
1048 }
1049
1050 const auto dummy_test_model_quant8_2 = TestModelManager::get().add("prelu_quant8_2", get_test_model_quant8_2());
1051
1052 } // namespace generated_tests::prelu
1053
1054 namespace generated_tests::prelu {
1055
get_test_model_quant8_all_inputs_as_internal_2()1056 const TestModel& get_test_model_quant8_all_inputs_as_internal_2() {
1057 static TestModel model = {
1058 .expectFailure = false,
1059 .expectedMultinomialDistributionTolerance = 0,
1060 .isRelaxed = false,
1061 .main = {
1062 .inputIndexes = {3},
1063 .operands = {{ // input
1064 .channelQuant = {},
1065 .data = TestBuffer::createFromVector<uint8_t>({}),
1066 .dimensions = {1, 2, 2, 3},
1067 .isIgnored = false,
1068 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1069 .numberOfConsumers = 1,
1070 .scale = 0.25f,
1071 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1072 .zeroPoint = 128
1073 }, { // alpha
1074 .channelQuant = {},
1075 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
1076 .dimensions = {1, 1, 3},
1077 .isIgnored = false,
1078 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1079 .numberOfConsumers = 1,
1080 .scale = 0.25f,
1081 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1082 .zeroPoint = 50
1083 }, { // output
1084 .channelQuant = {},
1085 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 124, 124, 124, 120, 116, 112, 120, 112, 104}),
1086 .dimensions = {1, 2, 2, 3},
1087 .isIgnored = false,
1088 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1089 .numberOfConsumers = 0,
1090 .scale = 0.25f,
1091 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1092 .zeroPoint = 120
1093 }, { // input_new
1094 .channelQuant = {},
1095 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1096 .dimensions = {1, 2, 2, 3},
1097 .isIgnored = false,
1098 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1099 .numberOfConsumers = 1,
1100 .scale = 0.25f,
1101 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1102 .zeroPoint = 128
1103 }, { // placeholder9
1104 .channelQuant = {},
1105 .data = TestBuffer::createFromVector<uint8_t>({128}),
1106 .dimensions = {1},
1107 .isIgnored = false,
1108 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1109 .numberOfConsumers = 1,
1110 .scale = 0.25f,
1111 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1112 .zeroPoint = 128
1113 }, { // param9
1114 .channelQuant = {},
1115 .data = TestBuffer::createFromVector<int32_t>({0}),
1116 .dimensions = {},
1117 .isIgnored = false,
1118 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1119 .numberOfConsumers = 1,
1120 .scale = 0.0f,
1121 .type = TestOperandType::INT32,
1122 .zeroPoint = 0
1123 }},
1124 .operations = {{
1125 .inputs = {3, 4, 5},
1126 .outputs = {0},
1127 .type = TestOperationType::ADD
1128 }, {
1129 .inputs = {0, 1},
1130 .outputs = {2},
1131 .type = TestOperationType::PRELU
1132 }},
1133 .outputIndexes = {2}
1134 },
1135 .minSupportedVersion = TestHalVersion::V1_2,
1136 .referenced = {}
1137 };
1138 return model;
1139 }
1140
1141 const auto dummy_test_model_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("prelu_quant8_all_inputs_as_internal_2", get_test_model_quant8_all_inputs_as_internal_2());
1142
1143 } // namespace generated_tests::prelu
1144
1145 namespace generated_tests::prelu {
1146
get_test_model_quant8_all_tensors_as_inputs_2()1147 const TestModel& get_test_model_quant8_all_tensors_as_inputs_2() {
1148 static TestModel model = {
1149 .expectFailure = false,
1150 .expectedMultinomialDistributionTolerance = 0,
1151 .isRelaxed = false,
1152 .main = {
1153 .inputIndexes = {0, 1},
1154 .operands = {{ // input
1155 .channelQuant = {},
1156 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1157 .dimensions = {1, 2, 2, 3},
1158 .isIgnored = false,
1159 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1160 .numberOfConsumers = 1,
1161 .scale = 0.25f,
1162 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1163 .zeroPoint = 128
1164 }, { // alpha
1165 .channelQuant = {},
1166 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
1167 .dimensions = {1, 1, 3},
1168 .isIgnored = false,
1169 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1170 .numberOfConsumers = 1,
1171 .scale = 0.25f,
1172 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1173 .zeroPoint = 50
1174 }, { // output
1175 .channelQuant = {},
1176 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 124, 124, 124, 120, 116, 112, 120, 112, 104}),
1177 .dimensions = {1, 2, 2, 3},
1178 .isIgnored = false,
1179 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1180 .numberOfConsumers = 0,
1181 .scale = 0.25f,
1182 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1183 .zeroPoint = 120
1184 }},
1185 .operations = {{
1186 .inputs = {0, 1},
1187 .outputs = {2},
1188 .type = TestOperationType::PRELU
1189 }},
1190 .outputIndexes = {2}
1191 },
1192 .minSupportedVersion = TestHalVersion::V1_2,
1193 .referenced = {}
1194 };
1195 return model;
1196 }
1197
1198 const auto dummy_test_model_quant8_all_tensors_as_inputs_2 = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs_2", get_test_model_quant8_all_tensors_as_inputs_2());
1199
1200 } // namespace generated_tests::prelu
1201
1202 namespace generated_tests::prelu {
1203
get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_2()1204 const TestModel& get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_2() {
1205 static TestModel model = {
1206 .expectFailure = false,
1207 .expectedMultinomialDistributionTolerance = 0,
1208 .isRelaxed = false,
1209 .main = {
1210 .inputIndexes = {3, 6},
1211 .operands = {{ // input
1212 .channelQuant = {},
1213 .data = TestBuffer::createFromVector<uint8_t>({}),
1214 .dimensions = {1, 2, 2, 3},
1215 .isIgnored = false,
1216 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1217 .numberOfConsumers = 1,
1218 .scale = 0.25f,
1219 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1220 .zeroPoint = 128
1221 }, { // alpha
1222 .channelQuant = {},
1223 .data = TestBuffer::createFromVector<uint8_t>({}),
1224 .dimensions = {1, 1, 3},
1225 .isIgnored = false,
1226 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1227 .numberOfConsumers = 1,
1228 .scale = 0.25f,
1229 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1230 .zeroPoint = 50
1231 }, { // output
1232 .channelQuant = {},
1233 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 124, 124, 124, 120, 116, 112, 120, 112, 104}),
1234 .dimensions = {1, 2, 2, 3},
1235 .isIgnored = false,
1236 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1237 .numberOfConsumers = 0,
1238 .scale = 0.25f,
1239 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1240 .zeroPoint = 120
1241 }, { // input_new
1242 .channelQuant = {},
1243 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1244 .dimensions = {1, 2, 2, 3},
1245 .isIgnored = false,
1246 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1247 .numberOfConsumers = 1,
1248 .scale = 0.25f,
1249 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1250 .zeroPoint = 128
1251 }, { // placeholder10
1252 .channelQuant = {},
1253 .data = TestBuffer::createFromVector<uint8_t>({128}),
1254 .dimensions = {1},
1255 .isIgnored = false,
1256 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1257 .numberOfConsumers = 1,
1258 .scale = 0.25f,
1259 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1260 .zeroPoint = 128
1261 }, { // param10
1262 .channelQuant = {},
1263 .data = TestBuffer::createFromVector<int32_t>({0}),
1264 .dimensions = {},
1265 .isIgnored = false,
1266 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1267 .numberOfConsumers = 1,
1268 .scale = 0.0f,
1269 .type = TestOperandType::INT32,
1270 .zeroPoint = 0
1271 }, { // alpha_new
1272 .channelQuant = {},
1273 .data = TestBuffer::createFromVector<uint8_t>({50, 54, 58}),
1274 .dimensions = {1, 1, 3},
1275 .isIgnored = false,
1276 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1277 .numberOfConsumers = 1,
1278 .scale = 0.25f,
1279 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1280 .zeroPoint = 50
1281 }, { // placeholder11
1282 .channelQuant = {},
1283 .data = TestBuffer::createFromVector<uint8_t>({50}),
1284 .dimensions = {1},
1285 .isIgnored = false,
1286 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1287 .numberOfConsumers = 1,
1288 .scale = 0.25f,
1289 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1290 .zeroPoint = 50
1291 }, { // param11
1292 .channelQuant = {},
1293 .data = TestBuffer::createFromVector<int32_t>({0}),
1294 .dimensions = {},
1295 .isIgnored = false,
1296 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1297 .numberOfConsumers = 1,
1298 .scale = 0.0f,
1299 .type = TestOperandType::INT32,
1300 .zeroPoint = 0
1301 }},
1302 .operations = {{
1303 .inputs = {3, 4, 5},
1304 .outputs = {0},
1305 .type = TestOperationType::ADD
1306 }, {
1307 .inputs = {6, 7, 8},
1308 .outputs = {1},
1309 .type = TestOperationType::ADD
1310 }, {
1311 .inputs = {0, 1},
1312 .outputs = {2},
1313 .type = TestOperationType::PRELU
1314 }},
1315 .outputIndexes = {2}
1316 },
1317 .minSupportedVersion = TestHalVersion::V1_2,
1318 .referenced = {}
1319 };
1320 return model;
1321 }
1322
1323 const auto dummy_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_2 = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs_all_inputs_as_internal_2", get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_2());
1324
1325 } // namespace generated_tests::prelu
1326
1327 namespace generated_tests::prelu {
1328
get_test_model_quant8_3()1329 const TestModel& get_test_model_quant8_3() {
1330 static TestModel model = {
1331 .expectFailure = false,
1332 .expectedMultinomialDistributionTolerance = 0,
1333 .isRelaxed = false,
1334 .main = {
1335 .inputIndexes = {0},
1336 .operands = {{ // input
1337 .channelQuant = {},
1338 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1339 .dimensions = {1, 2, 2, 3},
1340 .isIgnored = false,
1341 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1342 .numberOfConsumers = 1,
1343 .scale = 0.25f,
1344 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1345 .zeroPoint = 128
1346 }, { // alpha
1347 .channelQuant = {},
1348 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1349 .dimensions = {1, 1, 3},
1350 .isIgnored = false,
1351 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1352 .numberOfConsumers = 1,
1353 .scale = 0.5f,
1354 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1355 .zeroPoint = 50
1356 }, { // output
1357 .channelQuant = {},
1358 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 128, 128, 128, 120, 112, 104, 120, 104, 88}),
1359 .dimensions = {1, 2, 2, 3},
1360 .isIgnored = false,
1361 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1362 .numberOfConsumers = 0,
1363 .scale = 0.125f,
1364 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1365 .zeroPoint = 120
1366 }},
1367 .operations = {{
1368 .inputs = {0, 1},
1369 .outputs = {2},
1370 .type = TestOperationType::PRELU
1371 }},
1372 .outputIndexes = {2}
1373 },
1374 .minSupportedVersion = TestHalVersion::V1_2,
1375 .referenced = {}
1376 };
1377 return model;
1378 }
1379
1380 const auto dummy_test_model_quant8_3 = TestModelManager::get().add("prelu_quant8_3", get_test_model_quant8_3());
1381
1382 } // namespace generated_tests::prelu
1383
1384 namespace generated_tests::prelu {
1385
get_test_model_quant8_all_inputs_as_internal_3()1386 const TestModel& get_test_model_quant8_all_inputs_as_internal_3() {
1387 static TestModel model = {
1388 .expectFailure = false,
1389 .expectedMultinomialDistributionTolerance = 0,
1390 .isRelaxed = false,
1391 .main = {
1392 .inputIndexes = {3},
1393 .operands = {{ // input
1394 .channelQuant = {},
1395 .data = TestBuffer::createFromVector<uint8_t>({}),
1396 .dimensions = {1, 2, 2, 3},
1397 .isIgnored = false,
1398 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1399 .numberOfConsumers = 1,
1400 .scale = 0.25f,
1401 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1402 .zeroPoint = 128
1403 }, { // alpha
1404 .channelQuant = {},
1405 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1406 .dimensions = {1, 1, 3},
1407 .isIgnored = false,
1408 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1409 .numberOfConsumers = 1,
1410 .scale = 0.5f,
1411 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1412 .zeroPoint = 50
1413 }, { // output
1414 .channelQuant = {},
1415 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 128, 128, 128, 120, 112, 104, 120, 104, 88}),
1416 .dimensions = {1, 2, 2, 3},
1417 .isIgnored = false,
1418 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1419 .numberOfConsumers = 0,
1420 .scale = 0.125f,
1421 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1422 .zeroPoint = 120
1423 }, { // input_new
1424 .channelQuant = {},
1425 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1426 .dimensions = {1, 2, 2, 3},
1427 .isIgnored = false,
1428 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1429 .numberOfConsumers = 1,
1430 .scale = 0.25f,
1431 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1432 .zeroPoint = 128
1433 }, { // placeholder12
1434 .channelQuant = {},
1435 .data = TestBuffer::createFromVector<uint8_t>({128}),
1436 .dimensions = {1},
1437 .isIgnored = false,
1438 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1439 .numberOfConsumers = 1,
1440 .scale = 0.25f,
1441 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1442 .zeroPoint = 128
1443 }, { // param12
1444 .channelQuant = {},
1445 .data = TestBuffer::createFromVector<int32_t>({0}),
1446 .dimensions = {},
1447 .isIgnored = false,
1448 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1449 .numberOfConsumers = 1,
1450 .scale = 0.0f,
1451 .type = TestOperandType::INT32,
1452 .zeroPoint = 0
1453 }},
1454 .operations = {{
1455 .inputs = {3, 4, 5},
1456 .outputs = {0},
1457 .type = TestOperationType::ADD
1458 }, {
1459 .inputs = {0, 1},
1460 .outputs = {2},
1461 .type = TestOperationType::PRELU
1462 }},
1463 .outputIndexes = {2}
1464 },
1465 .minSupportedVersion = TestHalVersion::V1_2,
1466 .referenced = {}
1467 };
1468 return model;
1469 }
1470
1471 const auto dummy_test_model_quant8_all_inputs_as_internal_3 = TestModelManager::get().add("prelu_quant8_all_inputs_as_internal_3", get_test_model_quant8_all_inputs_as_internal_3());
1472
1473 } // namespace generated_tests::prelu
1474
1475 namespace generated_tests::prelu {
1476
get_test_model_quant8_all_tensors_as_inputs_3()1477 const TestModel& get_test_model_quant8_all_tensors_as_inputs_3() {
1478 static TestModel model = {
1479 .expectFailure = false,
1480 .expectedMultinomialDistributionTolerance = 0,
1481 .isRelaxed = false,
1482 .main = {
1483 .inputIndexes = {0, 1},
1484 .operands = {{ // input
1485 .channelQuant = {},
1486 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1487 .dimensions = {1, 2, 2, 3},
1488 .isIgnored = false,
1489 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1490 .numberOfConsumers = 1,
1491 .scale = 0.25f,
1492 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1493 .zeroPoint = 128
1494 }, { // alpha
1495 .channelQuant = {},
1496 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1497 .dimensions = {1, 1, 3},
1498 .isIgnored = false,
1499 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1500 .numberOfConsumers = 1,
1501 .scale = 0.5f,
1502 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1503 .zeroPoint = 50
1504 }, { // output
1505 .channelQuant = {},
1506 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 128, 128, 128, 120, 112, 104, 120, 104, 88}),
1507 .dimensions = {1, 2, 2, 3},
1508 .isIgnored = false,
1509 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1510 .numberOfConsumers = 0,
1511 .scale = 0.125f,
1512 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1513 .zeroPoint = 120
1514 }},
1515 .operations = {{
1516 .inputs = {0, 1},
1517 .outputs = {2},
1518 .type = TestOperationType::PRELU
1519 }},
1520 .outputIndexes = {2}
1521 },
1522 .minSupportedVersion = TestHalVersion::V1_2,
1523 .referenced = {}
1524 };
1525 return model;
1526 }
1527
1528 const auto dummy_test_model_quant8_all_tensors_as_inputs_3 = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs_3", get_test_model_quant8_all_tensors_as_inputs_3());
1529
1530 } // namespace generated_tests::prelu
1531
1532 namespace generated_tests::prelu {
1533
get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_3()1534 const TestModel& get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_3() {
1535 static TestModel model = {
1536 .expectFailure = false,
1537 .expectedMultinomialDistributionTolerance = 0,
1538 .isRelaxed = false,
1539 .main = {
1540 .inputIndexes = {3, 6},
1541 .operands = {{ // input
1542 .channelQuant = {},
1543 .data = TestBuffer::createFromVector<uint8_t>({}),
1544 .dimensions = {1, 2, 2, 3},
1545 .isIgnored = false,
1546 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1547 .numberOfConsumers = 1,
1548 .scale = 0.25f,
1549 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1550 .zeroPoint = 128
1551 }, { // alpha
1552 .channelQuant = {},
1553 .data = TestBuffer::createFromVector<uint8_t>({}),
1554 .dimensions = {1, 1, 3},
1555 .isIgnored = false,
1556 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1557 .numberOfConsumers = 1,
1558 .scale = 0.5f,
1559 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1560 .zeroPoint = 50
1561 }, { // output
1562 .channelQuant = {},
1563 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 128, 128, 128, 120, 112, 104, 120, 104, 88}),
1564 .dimensions = {1, 2, 2, 3},
1565 .isIgnored = false,
1566 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1567 .numberOfConsumers = 0,
1568 .scale = 0.125f,
1569 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1570 .zeroPoint = 120
1571 }, { // input_new
1572 .channelQuant = {},
1573 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1574 .dimensions = {1, 2, 2, 3},
1575 .isIgnored = false,
1576 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1577 .numberOfConsumers = 1,
1578 .scale = 0.25f,
1579 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1580 .zeroPoint = 128
1581 }, { // placeholder13
1582 .channelQuant = {},
1583 .data = TestBuffer::createFromVector<uint8_t>({128}),
1584 .dimensions = {1},
1585 .isIgnored = false,
1586 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1587 .numberOfConsumers = 1,
1588 .scale = 0.25f,
1589 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1590 .zeroPoint = 128
1591 }, { // param13
1592 .channelQuant = {},
1593 .data = TestBuffer::createFromVector<int32_t>({0}),
1594 .dimensions = {},
1595 .isIgnored = false,
1596 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1597 .numberOfConsumers = 1,
1598 .scale = 0.0f,
1599 .type = TestOperandType::INT32,
1600 .zeroPoint = 0
1601 }, { // alpha_new
1602 .channelQuant = {},
1603 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1604 .dimensions = {1, 1, 3},
1605 .isIgnored = false,
1606 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1607 .numberOfConsumers = 1,
1608 .scale = 0.5f,
1609 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1610 .zeroPoint = 50
1611 }, { // placeholder14
1612 .channelQuant = {},
1613 .data = TestBuffer::createFromVector<uint8_t>({50}),
1614 .dimensions = {1},
1615 .isIgnored = false,
1616 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1617 .numberOfConsumers = 1,
1618 .scale = 0.5f,
1619 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1620 .zeroPoint = 50
1621 }, { // param14
1622 .channelQuant = {},
1623 .data = TestBuffer::createFromVector<int32_t>({0}),
1624 .dimensions = {},
1625 .isIgnored = false,
1626 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1627 .numberOfConsumers = 1,
1628 .scale = 0.0f,
1629 .type = TestOperandType::INT32,
1630 .zeroPoint = 0
1631 }},
1632 .operations = {{
1633 .inputs = {3, 4, 5},
1634 .outputs = {0},
1635 .type = TestOperationType::ADD
1636 }, {
1637 .inputs = {6, 7, 8},
1638 .outputs = {1},
1639 .type = TestOperationType::ADD
1640 }, {
1641 .inputs = {0, 1},
1642 .outputs = {2},
1643 .type = TestOperationType::PRELU
1644 }},
1645 .outputIndexes = {2}
1646 },
1647 .minSupportedVersion = TestHalVersion::V1_2,
1648 .referenced = {}
1649 };
1650 return model;
1651 }
1652
1653 const auto dummy_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_3 = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs_all_inputs_as_internal_3", get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_3());
1654
1655 } // namespace generated_tests::prelu
1656
1657 namespace generated_tests::prelu {
1658
get_test_model_quant8_4()1659 const TestModel& get_test_model_quant8_4() {
1660 static TestModel model = {
1661 .expectFailure = false,
1662 .expectedMultinomialDistributionTolerance = 0,
1663 .isRelaxed = false,
1664 .main = {
1665 .inputIndexes = {0},
1666 .operands = {{ // input
1667 .channelQuant = {},
1668 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1669 .dimensions = {1, 2, 2, 3},
1670 .isIgnored = false,
1671 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1672 .numberOfConsumers = 1,
1673 .scale = 0.25f,
1674 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1675 .zeroPoint = 128
1676 }, { // alpha
1677 .channelQuant = {},
1678 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1679 .dimensions = {1, 1, 3},
1680 .isIgnored = false,
1681 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1682 .numberOfConsumers = 1,
1683 .scale = 0.5f,
1684 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1685 .zeroPoint = 50
1686 }, { // output
1687 .channelQuant = {},
1688 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 130, 130, 130, 120, 110, 100, 120, 100, 80}),
1689 .dimensions = {1, 2, 2, 3},
1690 .isIgnored = false,
1691 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1692 .numberOfConsumers = 0,
1693 .scale = 0.1f,
1694 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1695 .zeroPoint = 120
1696 }},
1697 .operations = {{
1698 .inputs = {0, 1},
1699 .outputs = {2},
1700 .type = TestOperationType::PRELU
1701 }},
1702 .outputIndexes = {2}
1703 },
1704 .minSupportedVersion = TestHalVersion::V1_2,
1705 .referenced = {}
1706 };
1707 return model;
1708 }
1709
1710 const auto dummy_test_model_quant8_4 = TestModelManager::get().add("prelu_quant8_4", get_test_model_quant8_4());
1711
1712 } // namespace generated_tests::prelu
1713
1714 namespace generated_tests::prelu {
1715
get_test_model_quant8_all_inputs_as_internal_4()1716 const TestModel& get_test_model_quant8_all_inputs_as_internal_4() {
1717 static TestModel model = {
1718 .expectFailure = false,
1719 .expectedMultinomialDistributionTolerance = 0,
1720 .isRelaxed = false,
1721 .main = {
1722 .inputIndexes = {3},
1723 .operands = {{ // input
1724 .channelQuant = {},
1725 .data = TestBuffer::createFromVector<uint8_t>({}),
1726 .dimensions = {1, 2, 2, 3},
1727 .isIgnored = false,
1728 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1729 .numberOfConsumers = 1,
1730 .scale = 0.25f,
1731 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1732 .zeroPoint = 128
1733 }, { // alpha
1734 .channelQuant = {},
1735 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1736 .dimensions = {1, 1, 3},
1737 .isIgnored = false,
1738 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1739 .numberOfConsumers = 1,
1740 .scale = 0.5f,
1741 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1742 .zeroPoint = 50
1743 }, { // output
1744 .channelQuant = {},
1745 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 130, 130, 130, 120, 110, 100, 120, 100, 80}),
1746 .dimensions = {1, 2, 2, 3},
1747 .isIgnored = false,
1748 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1749 .numberOfConsumers = 0,
1750 .scale = 0.1f,
1751 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1752 .zeroPoint = 120
1753 }, { // input_new
1754 .channelQuant = {},
1755 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1756 .dimensions = {1, 2, 2, 3},
1757 .isIgnored = false,
1758 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1759 .numberOfConsumers = 1,
1760 .scale = 0.25f,
1761 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1762 .zeroPoint = 128
1763 }, { // placeholder15
1764 .channelQuant = {},
1765 .data = TestBuffer::createFromVector<uint8_t>({128}),
1766 .dimensions = {1},
1767 .isIgnored = false,
1768 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1769 .numberOfConsumers = 1,
1770 .scale = 0.25f,
1771 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1772 .zeroPoint = 128
1773 }, { // param15
1774 .channelQuant = {},
1775 .data = TestBuffer::createFromVector<int32_t>({0}),
1776 .dimensions = {},
1777 .isIgnored = false,
1778 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1779 .numberOfConsumers = 1,
1780 .scale = 0.0f,
1781 .type = TestOperandType::INT32,
1782 .zeroPoint = 0
1783 }},
1784 .operations = {{
1785 .inputs = {3, 4, 5},
1786 .outputs = {0},
1787 .type = TestOperationType::ADD
1788 }, {
1789 .inputs = {0, 1},
1790 .outputs = {2},
1791 .type = TestOperationType::PRELU
1792 }},
1793 .outputIndexes = {2}
1794 },
1795 .minSupportedVersion = TestHalVersion::V1_2,
1796 .referenced = {}
1797 };
1798 return model;
1799 }
1800
1801 const auto dummy_test_model_quant8_all_inputs_as_internal_4 = TestModelManager::get().add("prelu_quant8_all_inputs_as_internal_4", get_test_model_quant8_all_inputs_as_internal_4());
1802
1803 } // namespace generated_tests::prelu
1804
1805 namespace generated_tests::prelu {
1806
get_test_model_quant8_all_tensors_as_inputs_4()1807 const TestModel& get_test_model_quant8_all_tensors_as_inputs_4() {
1808 static TestModel model = {
1809 .expectFailure = false,
1810 .expectedMultinomialDistributionTolerance = 0,
1811 .isRelaxed = false,
1812 .main = {
1813 .inputIndexes = {0, 1},
1814 .operands = {{ // input
1815 .channelQuant = {},
1816 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1817 .dimensions = {1, 2, 2, 3},
1818 .isIgnored = false,
1819 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1820 .numberOfConsumers = 1,
1821 .scale = 0.25f,
1822 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1823 .zeroPoint = 128
1824 }, { // alpha
1825 .channelQuant = {},
1826 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1827 .dimensions = {1, 1, 3},
1828 .isIgnored = false,
1829 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1830 .numberOfConsumers = 1,
1831 .scale = 0.5f,
1832 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1833 .zeroPoint = 50
1834 }, { // output
1835 .channelQuant = {},
1836 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 130, 130, 130, 120, 110, 100, 120, 100, 80}),
1837 .dimensions = {1, 2, 2, 3},
1838 .isIgnored = false,
1839 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1840 .numberOfConsumers = 0,
1841 .scale = 0.1f,
1842 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1843 .zeroPoint = 120
1844 }},
1845 .operations = {{
1846 .inputs = {0, 1},
1847 .outputs = {2},
1848 .type = TestOperationType::PRELU
1849 }},
1850 .outputIndexes = {2}
1851 },
1852 .minSupportedVersion = TestHalVersion::V1_2,
1853 .referenced = {}
1854 };
1855 return model;
1856 }
1857
1858 const auto dummy_test_model_quant8_all_tensors_as_inputs_4 = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs_4", get_test_model_quant8_all_tensors_as_inputs_4());
1859
1860 } // namespace generated_tests::prelu
1861
1862 namespace generated_tests::prelu {
1863
get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_4()1864 const TestModel& get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_4() {
1865 static TestModel model = {
1866 .expectFailure = false,
1867 .expectedMultinomialDistributionTolerance = 0,
1868 .isRelaxed = false,
1869 .main = {
1870 .inputIndexes = {3, 6},
1871 .operands = {{ // input
1872 .channelQuant = {},
1873 .data = TestBuffer::createFromVector<uint8_t>({}),
1874 .dimensions = {1, 2, 2, 3},
1875 .isIgnored = false,
1876 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1877 .numberOfConsumers = 1,
1878 .scale = 0.25f,
1879 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1880 .zeroPoint = 128
1881 }, { // alpha
1882 .channelQuant = {},
1883 .data = TestBuffer::createFromVector<uint8_t>({}),
1884 .dimensions = {1, 1, 3},
1885 .isIgnored = false,
1886 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1887 .numberOfConsumers = 1,
1888 .scale = 0.5f,
1889 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1890 .zeroPoint = 50
1891 }, { // output
1892 .channelQuant = {},
1893 .data = TestBuffer::createFromVector<uint8_t>({120, 120, 120, 130, 130, 130, 120, 110, 100, 120, 100, 80}),
1894 .dimensions = {1, 2, 2, 3},
1895 .isIgnored = false,
1896 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1897 .numberOfConsumers = 0,
1898 .scale = 0.1f,
1899 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1900 .zeroPoint = 120
1901 }, { // input_new
1902 .channelQuant = {},
1903 .data = TestBuffer::createFromVector<uint8_t>({128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120}),
1904 .dimensions = {1, 2, 2, 3},
1905 .isIgnored = false,
1906 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1907 .numberOfConsumers = 1,
1908 .scale = 0.25f,
1909 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1910 .zeroPoint = 128
1911 }, { // placeholder16
1912 .channelQuant = {},
1913 .data = TestBuffer::createFromVector<uint8_t>({128}),
1914 .dimensions = {1},
1915 .isIgnored = false,
1916 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1917 .numberOfConsumers = 1,
1918 .scale = 0.25f,
1919 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1920 .zeroPoint = 128
1921 }, { // param16
1922 .channelQuant = {},
1923 .data = TestBuffer::createFromVector<int32_t>({0}),
1924 .dimensions = {},
1925 .isIgnored = false,
1926 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1927 .numberOfConsumers = 1,
1928 .scale = 0.0f,
1929 .type = TestOperandType::INT32,
1930 .zeroPoint = 0
1931 }, { // alpha_new
1932 .channelQuant = {},
1933 .data = TestBuffer::createFromVector<uint8_t>({50, 52, 54}),
1934 .dimensions = {1, 1, 3},
1935 .isIgnored = false,
1936 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1937 .numberOfConsumers = 1,
1938 .scale = 0.5f,
1939 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1940 .zeroPoint = 50
1941 }, { // placeholder17
1942 .channelQuant = {},
1943 .data = TestBuffer::createFromVector<uint8_t>({50}),
1944 .dimensions = {1},
1945 .isIgnored = false,
1946 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1947 .numberOfConsumers = 1,
1948 .scale = 0.5f,
1949 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1950 .zeroPoint = 50
1951 }, { // param17
1952 .channelQuant = {},
1953 .data = TestBuffer::createFromVector<int32_t>({0}),
1954 .dimensions = {},
1955 .isIgnored = false,
1956 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1957 .numberOfConsumers = 1,
1958 .scale = 0.0f,
1959 .type = TestOperandType::INT32,
1960 .zeroPoint = 0
1961 }},
1962 .operations = {{
1963 .inputs = {3, 4, 5},
1964 .outputs = {0},
1965 .type = TestOperationType::ADD
1966 }, {
1967 .inputs = {6, 7, 8},
1968 .outputs = {1},
1969 .type = TestOperationType::ADD
1970 }, {
1971 .inputs = {0, 1},
1972 .outputs = {2},
1973 .type = TestOperationType::PRELU
1974 }},
1975 .outputIndexes = {2}
1976 },
1977 .minSupportedVersion = TestHalVersion::V1_2,
1978 .referenced = {}
1979 };
1980 return model;
1981 }
1982
1983 const auto dummy_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_4 = TestModelManager::get().add("prelu_quant8_all_tensors_as_inputs_all_inputs_as_internal_4", get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal_4());
1984
1985 } // namespace generated_tests::prelu
1986
1987 namespace generated_tests::prelu {
1988
get_test_model_float16()1989 const TestModel& get_test_model_float16() {
1990 static TestModel model = {
1991 .expectFailure = false,
1992 .expectedMultinomialDistributionTolerance = 0,
1993 .isRelaxed = false,
1994 .main = {
1995 .inputIndexes = {0},
1996 .operands = {{ // input
1997 .channelQuant = {},
1998 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
1999 .dimensions = {1, 2, 2, 3},
2000 .isIgnored = false,
2001 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2002 .numberOfConsumers = 1,
2003 .scale = 0.0f,
2004 .type = TestOperandType::TENSOR_FLOAT16,
2005 .zeroPoint = 0
2006 }, { // alpha
2007 .channelQuant = {},
2008 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f}),
2009 .dimensions = {1, 1, 3},
2010 .isIgnored = false,
2011 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2012 .numberOfConsumers = 1,
2013 .scale = 0.0f,
2014 .type = TestOperandType::TENSOR_FLOAT16,
2015 .zeroPoint = 0
2016 }, { // output
2017 .channelQuant = {},
2018 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
2019 .dimensions = {1, 2, 2, 3},
2020 .isIgnored = false,
2021 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2022 .numberOfConsumers = 0,
2023 .scale = 0.0f,
2024 .type = TestOperandType::TENSOR_FLOAT16,
2025 .zeroPoint = 0
2026 }},
2027 .operations = {{
2028 .inputs = {0, 1},
2029 .outputs = {2},
2030 .type = TestOperationType::PRELU
2031 }},
2032 .outputIndexes = {2}
2033 },
2034 .minSupportedVersion = TestHalVersion::V1_2,
2035 .referenced = {}
2036 };
2037 return model;
2038 }
2039
2040 const auto dummy_test_model_float16 = TestModelManager::get().add("prelu_float16", get_test_model_float16());
2041
2042 } // namespace generated_tests::prelu
2043
2044 namespace generated_tests::prelu {
2045
get_test_model_float16_all_inputs_as_internal()2046 const TestModel& get_test_model_float16_all_inputs_as_internal() {
2047 static TestModel model = {
2048 .expectFailure = false,
2049 .expectedMultinomialDistributionTolerance = 0,
2050 .isRelaxed = false,
2051 .main = {
2052 .inputIndexes = {3},
2053 .operands = {{ // input
2054 .channelQuant = {},
2055 .data = TestBuffer::createFromVector<_Float16>({}),
2056 .dimensions = {1, 2, 2, 3},
2057 .isIgnored = false,
2058 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2059 .numberOfConsumers = 1,
2060 .scale = 0.0f,
2061 .type = TestOperandType::TENSOR_FLOAT16,
2062 .zeroPoint = 0
2063 }, { // alpha
2064 .channelQuant = {},
2065 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f}),
2066 .dimensions = {1, 1, 3},
2067 .isIgnored = false,
2068 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2069 .numberOfConsumers = 1,
2070 .scale = 0.0f,
2071 .type = TestOperandType::TENSOR_FLOAT16,
2072 .zeroPoint = 0
2073 }, { // output
2074 .channelQuant = {},
2075 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
2076 .dimensions = {1, 2, 2, 3},
2077 .isIgnored = false,
2078 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2079 .numberOfConsumers = 0,
2080 .scale = 0.0f,
2081 .type = TestOperandType::TENSOR_FLOAT16,
2082 .zeroPoint = 0
2083 }, { // input_new
2084 .channelQuant = {},
2085 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
2086 .dimensions = {1, 2, 2, 3},
2087 .isIgnored = false,
2088 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2089 .numberOfConsumers = 1,
2090 .scale = 0.0f,
2091 .type = TestOperandType::TENSOR_FLOAT16,
2092 .zeroPoint = 0
2093 }, { // placeholder18
2094 .channelQuant = {},
2095 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
2096 .dimensions = {1},
2097 .isIgnored = false,
2098 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2099 .numberOfConsumers = 1,
2100 .scale = 0.0f,
2101 .type = TestOperandType::TENSOR_FLOAT16,
2102 .zeroPoint = 0
2103 }, { // param18
2104 .channelQuant = {},
2105 .data = TestBuffer::createFromVector<int32_t>({0}),
2106 .dimensions = {},
2107 .isIgnored = false,
2108 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2109 .numberOfConsumers = 1,
2110 .scale = 0.0f,
2111 .type = TestOperandType::INT32,
2112 .zeroPoint = 0
2113 }},
2114 .operations = {{
2115 .inputs = {3, 4, 5},
2116 .outputs = {0},
2117 .type = TestOperationType::ADD
2118 }, {
2119 .inputs = {0, 1},
2120 .outputs = {2},
2121 .type = TestOperationType::PRELU
2122 }},
2123 .outputIndexes = {2}
2124 },
2125 .minSupportedVersion = TestHalVersion::V1_2,
2126 .referenced = {}
2127 };
2128 return model;
2129 }
2130
2131 const auto dummy_test_model_float16_all_inputs_as_internal = TestModelManager::get().add("prelu_float16_all_inputs_as_internal", get_test_model_float16_all_inputs_as_internal());
2132
2133 } // namespace generated_tests::prelu
2134
2135 namespace generated_tests::prelu {
2136
get_test_model_float16_all_tensors_as_inputs()2137 const TestModel& get_test_model_float16_all_tensors_as_inputs() {
2138 static TestModel model = {
2139 .expectFailure = false,
2140 .expectedMultinomialDistributionTolerance = 0,
2141 .isRelaxed = false,
2142 .main = {
2143 .inputIndexes = {0, 1},
2144 .operands = {{ // input
2145 .channelQuant = {},
2146 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
2147 .dimensions = {1, 2, 2, 3},
2148 .isIgnored = false,
2149 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2150 .numberOfConsumers = 1,
2151 .scale = 0.0f,
2152 .type = TestOperandType::TENSOR_FLOAT16,
2153 .zeroPoint = 0
2154 }, { // alpha
2155 .channelQuant = {},
2156 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f}),
2157 .dimensions = {1, 1, 3},
2158 .isIgnored = false,
2159 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2160 .numberOfConsumers = 1,
2161 .scale = 0.0f,
2162 .type = TestOperandType::TENSOR_FLOAT16,
2163 .zeroPoint = 0
2164 }, { // output
2165 .channelQuant = {},
2166 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
2167 .dimensions = {1, 2, 2, 3},
2168 .isIgnored = false,
2169 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2170 .numberOfConsumers = 0,
2171 .scale = 0.0f,
2172 .type = TestOperandType::TENSOR_FLOAT16,
2173 .zeroPoint = 0
2174 }},
2175 .operations = {{
2176 .inputs = {0, 1},
2177 .outputs = {2},
2178 .type = TestOperationType::PRELU
2179 }},
2180 .outputIndexes = {2}
2181 },
2182 .minSupportedVersion = TestHalVersion::V1_2,
2183 .referenced = {}
2184 };
2185 return model;
2186 }
2187
2188 const auto dummy_test_model_float16_all_tensors_as_inputs = TestModelManager::get().add("prelu_float16_all_tensors_as_inputs", get_test_model_float16_all_tensors_as_inputs());
2189
2190 } // namespace generated_tests::prelu
2191
2192 namespace generated_tests::prelu {
2193
get_test_model_float16_all_tensors_as_inputs_all_inputs_as_internal()2194 const TestModel& get_test_model_float16_all_tensors_as_inputs_all_inputs_as_internal() {
2195 static TestModel model = {
2196 .expectFailure = false,
2197 .expectedMultinomialDistributionTolerance = 0,
2198 .isRelaxed = false,
2199 .main = {
2200 .inputIndexes = {3, 6},
2201 .operands = {{ // input
2202 .channelQuant = {},
2203 .data = TestBuffer::createFromVector<_Float16>({}),
2204 .dimensions = {1, 2, 2, 3},
2205 .isIgnored = false,
2206 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2207 .numberOfConsumers = 1,
2208 .scale = 0.0f,
2209 .type = TestOperandType::TENSOR_FLOAT16,
2210 .zeroPoint = 0
2211 }, { // alpha
2212 .channelQuant = {},
2213 .data = TestBuffer::createFromVector<_Float16>({}),
2214 .dimensions = {1, 1, 3},
2215 .isIgnored = false,
2216 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2217 .numberOfConsumers = 1,
2218 .scale = 0.0f,
2219 .type = TestOperandType::TENSOR_FLOAT16,
2220 .zeroPoint = 0
2221 }, { // output
2222 .channelQuant = {},
2223 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f}),
2224 .dimensions = {1, 2, 2, 3},
2225 .isIgnored = false,
2226 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2227 .numberOfConsumers = 0,
2228 .scale = 0.0f,
2229 .type = TestOperandType::TENSOR_FLOAT16,
2230 .zeroPoint = 0
2231 }, { // input_new
2232 .channelQuant = {},
2233 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f}),
2234 .dimensions = {1, 2, 2, 3},
2235 .isIgnored = false,
2236 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2237 .numberOfConsumers = 1,
2238 .scale = 0.0f,
2239 .type = TestOperandType::TENSOR_FLOAT16,
2240 .zeroPoint = 0
2241 }, { // placeholder19
2242 .channelQuant = {},
2243 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
2244 .dimensions = {1},
2245 .isIgnored = false,
2246 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2247 .numberOfConsumers = 1,
2248 .scale = 0.0f,
2249 .type = TestOperandType::TENSOR_FLOAT16,
2250 .zeroPoint = 0
2251 }, { // param19
2252 .channelQuant = {},
2253 .data = TestBuffer::createFromVector<int32_t>({0}),
2254 .dimensions = {},
2255 .isIgnored = false,
2256 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2257 .numberOfConsumers = 1,
2258 .scale = 0.0f,
2259 .type = TestOperandType::INT32,
2260 .zeroPoint = 0
2261 }, { // alpha_new
2262 .channelQuant = {},
2263 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f}),
2264 .dimensions = {1, 1, 3},
2265 .isIgnored = false,
2266 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2267 .numberOfConsumers = 1,
2268 .scale = 0.0f,
2269 .type = TestOperandType::TENSOR_FLOAT16,
2270 .zeroPoint = 0
2271 }, { // placeholder20
2272 .channelQuant = {},
2273 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
2274 .dimensions = {1},
2275 .isIgnored = false,
2276 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2277 .numberOfConsumers = 1,
2278 .scale = 0.0f,
2279 .type = TestOperandType::TENSOR_FLOAT16,
2280 .zeroPoint = 0
2281 }, { // param20
2282 .channelQuant = {},
2283 .data = TestBuffer::createFromVector<int32_t>({0}),
2284 .dimensions = {},
2285 .isIgnored = false,
2286 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2287 .numberOfConsumers = 1,
2288 .scale = 0.0f,
2289 .type = TestOperandType::INT32,
2290 .zeroPoint = 0
2291 }},
2292 .operations = {{
2293 .inputs = {3, 4, 5},
2294 .outputs = {0},
2295 .type = TestOperationType::ADD
2296 }, {
2297 .inputs = {6, 7, 8},
2298 .outputs = {1},
2299 .type = TestOperationType::ADD
2300 }, {
2301 .inputs = {0, 1},
2302 .outputs = {2},
2303 .type = TestOperationType::PRELU
2304 }},
2305 .outputIndexes = {2}
2306 },
2307 .minSupportedVersion = TestHalVersion::V1_2,
2308 .referenced = {}
2309 };
2310 return model;
2311 }
2312
2313 const auto dummy_test_model_float16_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("prelu_float16_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_float16_all_tensors_as_inputs_all_inputs_as_internal());
2314
2315 } // namespace generated_tests::prelu
2316
2317