1 // Generated from softmax_v1_2.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper;
6
7 namespace generated_tests::softmax_v1_2 {
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 = {{ // op1
17 .channelQuant = {},
18 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
19 .dimensions = {2, 2, 2, 5},
20 .isIgnored = false,
21 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22 .numberOfConsumers = 1,
23 .scale = 0.0f,
24 .type = TestOperandType::TENSOR_FLOAT32,
25 .zeroPoint = 0
26 }, { // param
27 .channelQuant = {},
28 .data = TestBuffer::createFromVector<float>({1.0f}),
29 .dimensions = {},
30 .isIgnored = false,
31 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
32 .numberOfConsumers = 1,
33 .scale = 0.0f,
34 .type = TestOperandType::FLOAT32,
35 .zeroPoint = 0
36 }, { // op2
37 .channelQuant = {},
38 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
39 .dimensions = {2, 2, 2, 5},
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::SOFTMAX
51 }},
52 .outputIndexes = {2}
53 },
54 .minSupportedVersion = TestHalVersion::V1_0,
55 .referenced = {}
56 };
57 return model;
58 }
59
60 const auto dummy_test_model = TestModelManager::get().add("softmax_v1_2", get_test_model());
61
62 } // namespace generated_tests::softmax_v1_2
63
64 namespace generated_tests::softmax_v1_2 {
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 = {{ // op1
74 .channelQuant = {},
75 .data = TestBuffer::createFromVector<float>({}),
76 .dimensions = {2, 2, 2, 5},
77 .isIgnored = false,
78 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
79 .numberOfConsumers = 1,
80 .scale = 0.0f,
81 .type = TestOperandType::TENSOR_FLOAT32,
82 .zeroPoint = 0
83 }, { // param
84 .channelQuant = {},
85 .data = TestBuffer::createFromVector<float>({1.0f}),
86 .dimensions = {},
87 .isIgnored = false,
88 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
89 .numberOfConsumers = 1,
90 .scale = 0.0f,
91 .type = TestOperandType::FLOAT32,
92 .zeroPoint = 0
93 }, { // op2
94 .channelQuant = {},
95 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
96 .dimensions = {2, 2, 2, 5},
97 .isIgnored = false,
98 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
99 .numberOfConsumers = 0,
100 .scale = 0.0f,
101 .type = TestOperandType::TENSOR_FLOAT32,
102 .zeroPoint = 0
103 }, { // op1_new
104 .channelQuant = {},
105 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
106 .dimensions = {2, 2, 2, 5},
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 }, { // param18
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::SOFTMAX
142 }},
143 .outputIndexes = {2}
144 },
145 .minSupportedVersion = TestHalVersion::V1_0,
146 .referenced = {}
147 };
148 return model;
149 }
150
151 const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_all_inputs_as_internal", get_test_model_all_inputs_as_internal());
152
153 } // namespace generated_tests::softmax_v1_2
154
155 namespace generated_tests::softmax_v1_2 {
156
get_test_model_dim1_axis0()157 const TestModel& get_test_model_dim1_axis0() {
158 static TestModel model = {
159 .expectFailure = false,
160 .expectedMultinomialDistributionTolerance = 0,
161 .isRelaxed = false,
162 .main = {
163 .inputIndexes = {0},
164 .operands = {{ // op1
165 .channelQuant = {},
166 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
167 .dimensions = {5},
168 .isIgnored = false,
169 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
170 .numberOfConsumers = 1,
171 .scale = 0.0f,
172 .type = TestOperandType::TENSOR_FLOAT32,
173 .zeroPoint = 0
174 }, { // param
175 .channelQuant = {},
176 .data = TestBuffer::createFromVector<float>({1.0f}),
177 .dimensions = {},
178 .isIgnored = false,
179 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
180 .numberOfConsumers = 1,
181 .scale = 0.0f,
182 .type = TestOperandType::FLOAT32,
183 .zeroPoint = 0
184 }, { // op2
185 .channelQuant = {},
186 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
187 .dimensions = {5},
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::SOFTMAX
199 }},
200 .outputIndexes = {2}
201 },
202 .minSupportedVersion = TestHalVersion::V1_2,
203 .referenced = {}
204 };
205 return model;
206 }
207
208 const auto dummy_test_model_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_dim1_axis0", get_test_model_dim1_axis0());
209
210 } // namespace generated_tests::softmax_v1_2
211
212 namespace generated_tests::softmax_v1_2 {
213
get_test_model_dim1_axis0_all_inputs_as_internal()214 const TestModel& get_test_model_dim1_axis0_all_inputs_as_internal() {
215 static TestModel model = {
216 .expectFailure = false,
217 .expectedMultinomialDistributionTolerance = 0,
218 .isRelaxed = false,
219 .main = {
220 .inputIndexes = {3},
221 .operands = {{ // op1
222 .channelQuant = {},
223 .data = TestBuffer::createFromVector<float>({}),
224 .dimensions = {5},
225 .isIgnored = false,
226 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
227 .numberOfConsumers = 1,
228 .scale = 0.0f,
229 .type = TestOperandType::TENSOR_FLOAT32,
230 .zeroPoint = 0
231 }, { // param
232 .channelQuant = {},
233 .data = TestBuffer::createFromVector<float>({1.0f}),
234 .dimensions = {},
235 .isIgnored = false,
236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
237 .numberOfConsumers = 1,
238 .scale = 0.0f,
239 .type = TestOperandType::FLOAT32,
240 .zeroPoint = 0
241 }, { // op2
242 .channelQuant = {},
243 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
244 .dimensions = {5},
245 .isIgnored = false,
246 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
247 .numberOfConsumers = 0,
248 .scale = 0.0f,
249 .type = TestOperandType::TENSOR_FLOAT32,
250 .zeroPoint = 0
251 }, { // op1_new
252 .channelQuant = {},
253 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
254 .dimensions = {5},
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 }, { // param19
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 }},
282 .operations = {{
283 .inputs = {3, 4, 5},
284 .outputs = {0},
285 .type = TestOperationType::ADD
286 }, {
287 .inputs = {0, 1},
288 .outputs = {2},
289 .type = TestOperationType::SOFTMAX
290 }},
291 .outputIndexes = {2}
292 },
293 .minSupportedVersion = TestHalVersion::V1_2,
294 .referenced = {}
295 };
296 return model;
297 }
298
299 const auto dummy_test_model_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_dim1_axis0_all_inputs_as_internal", get_test_model_dim1_axis0_all_inputs_as_internal());
300
301 } // namespace generated_tests::softmax_v1_2
302
303 namespace generated_tests::softmax_v1_2 {
304
get_test_model_dim3_axis2()305 const TestModel& get_test_model_dim3_axis2() {
306 static TestModel model = {
307 .expectFailure = false,
308 .expectedMultinomialDistributionTolerance = 0,
309 .isRelaxed = false,
310 .main = {
311 .inputIndexes = {0},
312 .operands = {{ // op1
313 .channelQuant = {},
314 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
315 .dimensions = {2, 2, 5},
316 .isIgnored = false,
317 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
318 .numberOfConsumers = 1,
319 .scale = 0.0f,
320 .type = TestOperandType::TENSOR_FLOAT32,
321 .zeroPoint = 0
322 }, { // param
323 .channelQuant = {},
324 .data = TestBuffer::createFromVector<float>({1.0f}),
325 .dimensions = {},
326 .isIgnored = false,
327 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
328 .numberOfConsumers = 1,
329 .scale = 0.0f,
330 .type = TestOperandType::FLOAT32,
331 .zeroPoint = 0
332 }, { // op2
333 .channelQuant = {},
334 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
335 .dimensions = {2, 2, 5},
336 .isIgnored = false,
337 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
338 .numberOfConsumers = 0,
339 .scale = 0.0f,
340 .type = TestOperandType::TENSOR_FLOAT32,
341 .zeroPoint = 0
342 }},
343 .operations = {{
344 .inputs = {0, 1},
345 .outputs = {2},
346 .type = TestOperationType::SOFTMAX
347 }},
348 .outputIndexes = {2}
349 },
350 .minSupportedVersion = TestHalVersion::V1_2,
351 .referenced = {}
352 };
353 return model;
354 }
355
356 const auto dummy_test_model_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_dim3_axis2", get_test_model_dim3_axis2());
357
358 } // namespace generated_tests::softmax_v1_2
359
360 namespace generated_tests::softmax_v1_2 {
361
get_test_model_dim3_axis2_all_inputs_as_internal()362 const TestModel& get_test_model_dim3_axis2_all_inputs_as_internal() {
363 static TestModel model = {
364 .expectFailure = false,
365 .expectedMultinomialDistributionTolerance = 0,
366 .isRelaxed = false,
367 .main = {
368 .inputIndexes = {3},
369 .operands = {{ // op1
370 .channelQuant = {},
371 .data = TestBuffer::createFromVector<float>({}),
372 .dimensions = {2, 2, 5},
373 .isIgnored = false,
374 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
375 .numberOfConsumers = 1,
376 .scale = 0.0f,
377 .type = TestOperandType::TENSOR_FLOAT32,
378 .zeroPoint = 0
379 }, { // param
380 .channelQuant = {},
381 .data = TestBuffer::createFromVector<float>({1.0f}),
382 .dimensions = {},
383 .isIgnored = false,
384 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
385 .numberOfConsumers = 1,
386 .scale = 0.0f,
387 .type = TestOperandType::FLOAT32,
388 .zeroPoint = 0
389 }, { // op2
390 .channelQuant = {},
391 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
392 .dimensions = {2, 2, 5},
393 .isIgnored = false,
394 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
395 .numberOfConsumers = 0,
396 .scale = 0.0f,
397 .type = TestOperandType::TENSOR_FLOAT32,
398 .zeroPoint = 0
399 }, { // op1_new
400 .channelQuant = {},
401 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
402 .dimensions = {2, 2, 5},
403 .isIgnored = false,
404 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
405 .numberOfConsumers = 1,
406 .scale = 0.0f,
407 .type = TestOperandType::TENSOR_FLOAT32,
408 .zeroPoint = 0
409 }, { // placeholder2
410 .channelQuant = {},
411 .data = TestBuffer::createFromVector<float>({0.0f}),
412 .dimensions = {1},
413 .isIgnored = false,
414 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
415 .numberOfConsumers = 1,
416 .scale = 0.0f,
417 .type = TestOperandType::TENSOR_FLOAT32,
418 .zeroPoint = 0
419 }, { // param20
420 .channelQuant = {},
421 .data = TestBuffer::createFromVector<int32_t>({0}),
422 .dimensions = {},
423 .isIgnored = false,
424 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
425 .numberOfConsumers = 1,
426 .scale = 0.0f,
427 .type = TestOperandType::INT32,
428 .zeroPoint = 0
429 }},
430 .operations = {{
431 .inputs = {3, 4, 5},
432 .outputs = {0},
433 .type = TestOperationType::ADD
434 }, {
435 .inputs = {0, 1},
436 .outputs = {2},
437 .type = TestOperationType::SOFTMAX
438 }},
439 .outputIndexes = {2}
440 },
441 .minSupportedVersion = TestHalVersion::V1_2,
442 .referenced = {}
443 };
444 return model;
445 }
446
447 const auto dummy_test_model_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_dim3_axis2_all_inputs_as_internal", get_test_model_dim3_axis2_all_inputs_as_internal());
448
449 } // namespace generated_tests::softmax_v1_2
450
451 namespace generated_tests::softmax_v1_2 {
452
get_test_model_relaxed()453 const TestModel& get_test_model_relaxed() {
454 static TestModel model = {
455 .expectFailure = false,
456 .expectedMultinomialDistributionTolerance = 0,
457 .isRelaxed = true,
458 .main = {
459 .inputIndexes = {0},
460 .operands = {{ // op1
461 .channelQuant = {},
462 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
463 .dimensions = {2, 2, 2, 5},
464 .isIgnored = false,
465 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
466 .numberOfConsumers = 1,
467 .scale = 0.0f,
468 .type = TestOperandType::TENSOR_FLOAT32,
469 .zeroPoint = 0
470 }, { // param
471 .channelQuant = {},
472 .data = TestBuffer::createFromVector<float>({1.0f}),
473 .dimensions = {},
474 .isIgnored = false,
475 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
476 .numberOfConsumers = 1,
477 .scale = 0.0f,
478 .type = TestOperandType::FLOAT32,
479 .zeroPoint = 0
480 }, { // op2
481 .channelQuant = {},
482 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
483 .dimensions = {2, 2, 2, 5},
484 .isIgnored = false,
485 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
486 .numberOfConsumers = 0,
487 .scale = 0.0f,
488 .type = TestOperandType::TENSOR_FLOAT32,
489 .zeroPoint = 0
490 }},
491 .operations = {{
492 .inputs = {0, 1},
493 .outputs = {2},
494 .type = TestOperationType::SOFTMAX
495 }},
496 .outputIndexes = {2}
497 },
498 .minSupportedVersion = TestHalVersion::UNKNOWN,
499 .referenced = {}
500 };
501 return model;
502 }
503
504 const auto dummy_test_model_relaxed = TestModelManager::get().add("softmax_v1_2_relaxed", get_test_model_relaxed());
505
506 } // namespace generated_tests::softmax_v1_2
507
508 namespace generated_tests::softmax_v1_2 {
509
get_test_model_relaxed_all_inputs_as_internal()510 const TestModel& get_test_model_relaxed_all_inputs_as_internal() {
511 static TestModel model = {
512 .expectFailure = false,
513 .expectedMultinomialDistributionTolerance = 0,
514 .isRelaxed = true,
515 .main = {
516 .inputIndexes = {3},
517 .operands = {{ // op1
518 .channelQuant = {},
519 .data = TestBuffer::createFromVector<float>({}),
520 .dimensions = {2, 2, 2, 5},
521 .isIgnored = false,
522 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
523 .numberOfConsumers = 1,
524 .scale = 0.0f,
525 .type = TestOperandType::TENSOR_FLOAT32,
526 .zeroPoint = 0
527 }, { // param
528 .channelQuant = {},
529 .data = TestBuffer::createFromVector<float>({1.0f}),
530 .dimensions = {},
531 .isIgnored = false,
532 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
533 .numberOfConsumers = 1,
534 .scale = 0.0f,
535 .type = TestOperandType::FLOAT32,
536 .zeroPoint = 0
537 }, { // op2
538 .channelQuant = {},
539 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
540 .dimensions = {2, 2, 2, 5},
541 .isIgnored = false,
542 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
543 .numberOfConsumers = 0,
544 .scale = 0.0f,
545 .type = TestOperandType::TENSOR_FLOAT32,
546 .zeroPoint = 0
547 }, { // op1_new
548 .channelQuant = {},
549 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
550 .dimensions = {2, 2, 2, 5},
551 .isIgnored = false,
552 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
553 .numberOfConsumers = 1,
554 .scale = 0.0f,
555 .type = TestOperandType::TENSOR_FLOAT32,
556 .zeroPoint = 0
557 }, { // placeholder3
558 .channelQuant = {},
559 .data = TestBuffer::createFromVector<float>({0.0f}),
560 .dimensions = {1},
561 .isIgnored = false,
562 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
563 .numberOfConsumers = 1,
564 .scale = 0.0f,
565 .type = TestOperandType::TENSOR_FLOAT32,
566 .zeroPoint = 0
567 }, { // param21
568 .channelQuant = {},
569 .data = TestBuffer::createFromVector<int32_t>({0}),
570 .dimensions = {},
571 .isIgnored = false,
572 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
573 .numberOfConsumers = 1,
574 .scale = 0.0f,
575 .type = TestOperandType::INT32,
576 .zeroPoint = 0
577 }},
578 .operations = {{
579 .inputs = {3, 4, 5},
580 .outputs = {0},
581 .type = TestOperationType::ADD
582 }, {
583 .inputs = {0, 1},
584 .outputs = {2},
585 .type = TestOperationType::SOFTMAX
586 }},
587 .outputIndexes = {2}
588 },
589 .minSupportedVersion = TestHalVersion::UNKNOWN,
590 .referenced = {}
591 };
592 return model;
593 }
594
595 const auto dummy_test_model_relaxed_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_relaxed_all_inputs_as_internal", get_test_model_relaxed_all_inputs_as_internal());
596
597 } // namespace generated_tests::softmax_v1_2
598
599 namespace generated_tests::softmax_v1_2 {
600
get_test_model_relaxed_dim1_axis0()601 const TestModel& get_test_model_relaxed_dim1_axis0() {
602 static TestModel model = {
603 .expectFailure = false,
604 .expectedMultinomialDistributionTolerance = 0,
605 .isRelaxed = true,
606 .main = {
607 .inputIndexes = {0},
608 .operands = {{ // op1
609 .channelQuant = {},
610 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
611 .dimensions = {5},
612 .isIgnored = false,
613 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
614 .numberOfConsumers = 1,
615 .scale = 0.0f,
616 .type = TestOperandType::TENSOR_FLOAT32,
617 .zeroPoint = 0
618 }, { // param
619 .channelQuant = {},
620 .data = TestBuffer::createFromVector<float>({1.0f}),
621 .dimensions = {},
622 .isIgnored = false,
623 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
624 .numberOfConsumers = 1,
625 .scale = 0.0f,
626 .type = TestOperandType::FLOAT32,
627 .zeroPoint = 0
628 }, { // op2
629 .channelQuant = {},
630 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
631 .dimensions = {5},
632 .isIgnored = false,
633 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
634 .numberOfConsumers = 0,
635 .scale = 0.0f,
636 .type = TestOperandType::TENSOR_FLOAT32,
637 .zeroPoint = 0
638 }},
639 .operations = {{
640 .inputs = {0, 1},
641 .outputs = {2},
642 .type = TestOperationType::SOFTMAX
643 }},
644 .outputIndexes = {2}
645 },
646 .minSupportedVersion = TestHalVersion::UNKNOWN,
647 .referenced = {}
648 };
649 return model;
650 }
651
652 const auto dummy_test_model_relaxed_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_relaxed_dim1_axis0", get_test_model_relaxed_dim1_axis0());
653
654 } // namespace generated_tests::softmax_v1_2
655
656 namespace generated_tests::softmax_v1_2 {
657
get_test_model_relaxed_dim1_axis0_all_inputs_as_internal()658 const TestModel& get_test_model_relaxed_dim1_axis0_all_inputs_as_internal() {
659 static TestModel model = {
660 .expectFailure = false,
661 .expectedMultinomialDistributionTolerance = 0,
662 .isRelaxed = true,
663 .main = {
664 .inputIndexes = {3},
665 .operands = {{ // op1
666 .channelQuant = {},
667 .data = TestBuffer::createFromVector<float>({}),
668 .dimensions = {5},
669 .isIgnored = false,
670 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
671 .numberOfConsumers = 1,
672 .scale = 0.0f,
673 .type = TestOperandType::TENSOR_FLOAT32,
674 .zeroPoint = 0
675 }, { // param
676 .channelQuant = {},
677 .data = TestBuffer::createFromVector<float>({1.0f}),
678 .dimensions = {},
679 .isIgnored = false,
680 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
681 .numberOfConsumers = 1,
682 .scale = 0.0f,
683 .type = TestOperandType::FLOAT32,
684 .zeroPoint = 0
685 }, { // op2
686 .channelQuant = {},
687 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
688 .dimensions = {5},
689 .isIgnored = false,
690 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
691 .numberOfConsumers = 0,
692 .scale = 0.0f,
693 .type = TestOperandType::TENSOR_FLOAT32,
694 .zeroPoint = 0
695 }, { // op1_new
696 .channelQuant = {},
697 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
698 .dimensions = {5},
699 .isIgnored = false,
700 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
701 .numberOfConsumers = 1,
702 .scale = 0.0f,
703 .type = TestOperandType::TENSOR_FLOAT32,
704 .zeroPoint = 0
705 }, { // placeholder4
706 .channelQuant = {},
707 .data = TestBuffer::createFromVector<float>({0.0f}),
708 .dimensions = {1},
709 .isIgnored = false,
710 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
711 .numberOfConsumers = 1,
712 .scale = 0.0f,
713 .type = TestOperandType::TENSOR_FLOAT32,
714 .zeroPoint = 0
715 }, { // param22
716 .channelQuant = {},
717 .data = TestBuffer::createFromVector<int32_t>({0}),
718 .dimensions = {},
719 .isIgnored = false,
720 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
721 .numberOfConsumers = 1,
722 .scale = 0.0f,
723 .type = TestOperandType::INT32,
724 .zeroPoint = 0
725 }},
726 .operations = {{
727 .inputs = {3, 4, 5},
728 .outputs = {0},
729 .type = TestOperationType::ADD
730 }, {
731 .inputs = {0, 1},
732 .outputs = {2},
733 .type = TestOperationType::SOFTMAX
734 }},
735 .outputIndexes = {2}
736 },
737 .minSupportedVersion = TestHalVersion::UNKNOWN,
738 .referenced = {}
739 };
740 return model;
741 }
742
743 const auto dummy_test_model_relaxed_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_relaxed_dim1_axis0_all_inputs_as_internal", get_test_model_relaxed_dim1_axis0_all_inputs_as_internal());
744
745 } // namespace generated_tests::softmax_v1_2
746
747 namespace generated_tests::softmax_v1_2 {
748
get_test_model_relaxed_dim3_axis2()749 const TestModel& get_test_model_relaxed_dim3_axis2() {
750 static TestModel model = {
751 .expectFailure = false,
752 .expectedMultinomialDistributionTolerance = 0,
753 .isRelaxed = true,
754 .main = {
755 .inputIndexes = {0},
756 .operands = {{ // op1
757 .channelQuant = {},
758 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
759 .dimensions = {2, 2, 5},
760 .isIgnored = false,
761 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
762 .numberOfConsumers = 1,
763 .scale = 0.0f,
764 .type = TestOperandType::TENSOR_FLOAT32,
765 .zeroPoint = 0
766 }, { // param
767 .channelQuant = {},
768 .data = TestBuffer::createFromVector<float>({1.0f}),
769 .dimensions = {},
770 .isIgnored = false,
771 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
772 .numberOfConsumers = 1,
773 .scale = 0.0f,
774 .type = TestOperandType::FLOAT32,
775 .zeroPoint = 0
776 }, { // op2
777 .channelQuant = {},
778 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
779 .dimensions = {2, 2, 5},
780 .isIgnored = false,
781 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
782 .numberOfConsumers = 0,
783 .scale = 0.0f,
784 .type = TestOperandType::TENSOR_FLOAT32,
785 .zeroPoint = 0
786 }},
787 .operations = {{
788 .inputs = {0, 1},
789 .outputs = {2},
790 .type = TestOperationType::SOFTMAX
791 }},
792 .outputIndexes = {2}
793 },
794 .minSupportedVersion = TestHalVersion::UNKNOWN,
795 .referenced = {}
796 };
797 return model;
798 }
799
800 const auto dummy_test_model_relaxed_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_relaxed_dim3_axis2", get_test_model_relaxed_dim3_axis2());
801
802 } // namespace generated_tests::softmax_v1_2
803
804 namespace generated_tests::softmax_v1_2 {
805
get_test_model_relaxed_dim3_axis2_all_inputs_as_internal()806 const TestModel& get_test_model_relaxed_dim3_axis2_all_inputs_as_internal() {
807 static TestModel model = {
808 .expectFailure = false,
809 .expectedMultinomialDistributionTolerance = 0,
810 .isRelaxed = true,
811 .main = {
812 .inputIndexes = {3},
813 .operands = {{ // op1
814 .channelQuant = {},
815 .data = TestBuffer::createFromVector<float>({}),
816 .dimensions = {2, 2, 5},
817 .isIgnored = false,
818 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
819 .numberOfConsumers = 1,
820 .scale = 0.0f,
821 .type = TestOperandType::TENSOR_FLOAT32,
822 .zeroPoint = 0
823 }, { // param
824 .channelQuant = {},
825 .data = TestBuffer::createFromVector<float>({1.0f}),
826 .dimensions = {},
827 .isIgnored = false,
828 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
829 .numberOfConsumers = 1,
830 .scale = 0.0f,
831 .type = TestOperandType::FLOAT32,
832 .zeroPoint = 0
833 }, { // op2
834 .channelQuant = {},
835 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
836 .dimensions = {2, 2, 5},
837 .isIgnored = false,
838 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
839 .numberOfConsumers = 0,
840 .scale = 0.0f,
841 .type = TestOperandType::TENSOR_FLOAT32,
842 .zeroPoint = 0
843 }, { // op1_new
844 .channelQuant = {},
845 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
846 .dimensions = {2, 2, 5},
847 .isIgnored = false,
848 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
849 .numberOfConsumers = 1,
850 .scale = 0.0f,
851 .type = TestOperandType::TENSOR_FLOAT32,
852 .zeroPoint = 0
853 }, { // placeholder5
854 .channelQuant = {},
855 .data = TestBuffer::createFromVector<float>({0.0f}),
856 .dimensions = {1},
857 .isIgnored = false,
858 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
859 .numberOfConsumers = 1,
860 .scale = 0.0f,
861 .type = TestOperandType::TENSOR_FLOAT32,
862 .zeroPoint = 0
863 }, { // param23
864 .channelQuant = {},
865 .data = TestBuffer::createFromVector<int32_t>({0}),
866 .dimensions = {},
867 .isIgnored = false,
868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
869 .numberOfConsumers = 1,
870 .scale = 0.0f,
871 .type = TestOperandType::INT32,
872 .zeroPoint = 0
873 }},
874 .operations = {{
875 .inputs = {3, 4, 5},
876 .outputs = {0},
877 .type = TestOperationType::ADD
878 }, {
879 .inputs = {0, 1},
880 .outputs = {2},
881 .type = TestOperationType::SOFTMAX
882 }},
883 .outputIndexes = {2}
884 },
885 .minSupportedVersion = TestHalVersion::UNKNOWN,
886 .referenced = {}
887 };
888 return model;
889 }
890
891 const auto dummy_test_model_relaxed_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_relaxed_dim3_axis2_all_inputs_as_internal", get_test_model_relaxed_dim3_axis2_all_inputs_as_internal());
892
893 } // namespace generated_tests::softmax_v1_2
894
895 namespace generated_tests::softmax_v1_2 {
896
get_test_model_float16()897 const TestModel& get_test_model_float16() {
898 static TestModel model = {
899 .expectFailure = false,
900 .expectedMultinomialDistributionTolerance = 0,
901 .isRelaxed = false,
902 .main = {
903 .inputIndexes = {0},
904 .operands = {{ // op1
905 .channelQuant = {},
906 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
907 .dimensions = {2, 2, 2, 5},
908 .isIgnored = false,
909 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
910 .numberOfConsumers = 1,
911 .scale = 0.0f,
912 .type = TestOperandType::TENSOR_FLOAT16,
913 .zeroPoint = 0
914 }, { // param
915 .channelQuant = {},
916 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
917 .dimensions = {},
918 .isIgnored = false,
919 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
920 .numberOfConsumers = 1,
921 .scale = 0.0f,
922 .type = TestOperandType::FLOAT16,
923 .zeroPoint = 0
924 }, { // op2
925 .channelQuant = {},
926 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
927 .dimensions = {2, 2, 2, 5},
928 .isIgnored = false,
929 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
930 .numberOfConsumers = 0,
931 .scale = 0.0f,
932 .type = TestOperandType::TENSOR_FLOAT16,
933 .zeroPoint = 0
934 }},
935 .operations = {{
936 .inputs = {0, 1},
937 .outputs = {2},
938 .type = TestOperationType::SOFTMAX
939 }},
940 .outputIndexes = {2}
941 },
942 .minSupportedVersion = TestHalVersion::V1_2,
943 .referenced = {}
944 };
945 return model;
946 }
947
948 const auto dummy_test_model_float16 = TestModelManager::get().add("softmax_v1_2_float16", get_test_model_float16());
949
950 } // namespace generated_tests::softmax_v1_2
951
952 namespace generated_tests::softmax_v1_2 {
953
get_test_model_float16_all_inputs_as_internal()954 const TestModel& get_test_model_float16_all_inputs_as_internal() {
955 static TestModel model = {
956 .expectFailure = false,
957 .expectedMultinomialDistributionTolerance = 0,
958 .isRelaxed = false,
959 .main = {
960 .inputIndexes = {3},
961 .operands = {{ // op1
962 .channelQuant = {},
963 .data = TestBuffer::createFromVector<_Float16>({}),
964 .dimensions = {2, 2, 2, 5},
965 .isIgnored = false,
966 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
967 .numberOfConsumers = 1,
968 .scale = 0.0f,
969 .type = TestOperandType::TENSOR_FLOAT16,
970 .zeroPoint = 0
971 }, { // param
972 .channelQuant = {},
973 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
974 .dimensions = {},
975 .isIgnored = false,
976 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
977 .numberOfConsumers = 1,
978 .scale = 0.0f,
979 .type = TestOperandType::FLOAT16,
980 .zeroPoint = 0
981 }, { // op2
982 .channelQuant = {},
983 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
984 .dimensions = {2, 2, 2, 5},
985 .isIgnored = false,
986 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
987 .numberOfConsumers = 0,
988 .scale = 0.0f,
989 .type = TestOperandType::TENSOR_FLOAT16,
990 .zeroPoint = 0
991 }, { // op1_new
992 .channelQuant = {},
993 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
994 .dimensions = {2, 2, 2, 5},
995 .isIgnored = false,
996 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
997 .numberOfConsumers = 1,
998 .scale = 0.0f,
999 .type = TestOperandType::TENSOR_FLOAT16,
1000 .zeroPoint = 0
1001 }, { // placeholder6
1002 .channelQuant = {},
1003 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
1004 .dimensions = {1},
1005 .isIgnored = false,
1006 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1007 .numberOfConsumers = 1,
1008 .scale = 0.0f,
1009 .type = TestOperandType::TENSOR_FLOAT16,
1010 .zeroPoint = 0
1011 }, { // param24
1012 .channelQuant = {},
1013 .data = TestBuffer::createFromVector<int32_t>({0}),
1014 .dimensions = {},
1015 .isIgnored = false,
1016 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1017 .numberOfConsumers = 1,
1018 .scale = 0.0f,
1019 .type = TestOperandType::INT32,
1020 .zeroPoint = 0
1021 }},
1022 .operations = {{
1023 .inputs = {3, 4, 5},
1024 .outputs = {0},
1025 .type = TestOperationType::ADD
1026 }, {
1027 .inputs = {0, 1},
1028 .outputs = {2},
1029 .type = TestOperationType::SOFTMAX
1030 }},
1031 .outputIndexes = {2}
1032 },
1033 .minSupportedVersion = TestHalVersion::V1_2,
1034 .referenced = {}
1035 };
1036 return model;
1037 }
1038
1039 const auto dummy_test_model_float16_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_float16_all_inputs_as_internal", get_test_model_float16_all_inputs_as_internal());
1040
1041 } // namespace generated_tests::softmax_v1_2
1042
1043 namespace generated_tests::softmax_v1_2 {
1044
get_test_model_float16_dim1_axis0()1045 const TestModel& get_test_model_float16_dim1_axis0() {
1046 static TestModel model = {
1047 .expectFailure = false,
1048 .expectedMultinomialDistributionTolerance = 0,
1049 .isRelaxed = false,
1050 .main = {
1051 .inputIndexes = {0},
1052 .operands = {{ // op1
1053 .channelQuant = {},
1054 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
1055 .dimensions = {5},
1056 .isIgnored = false,
1057 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1058 .numberOfConsumers = 1,
1059 .scale = 0.0f,
1060 .type = TestOperandType::TENSOR_FLOAT16,
1061 .zeroPoint = 0
1062 }, { // param
1063 .channelQuant = {},
1064 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
1065 .dimensions = {},
1066 .isIgnored = false,
1067 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1068 .numberOfConsumers = 1,
1069 .scale = 0.0f,
1070 .type = TestOperandType::FLOAT16,
1071 .zeroPoint = 0
1072 }, { // op2
1073 .channelQuant = {},
1074 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
1075 .dimensions = {5},
1076 .isIgnored = false,
1077 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1078 .numberOfConsumers = 0,
1079 .scale = 0.0f,
1080 .type = TestOperandType::TENSOR_FLOAT16,
1081 .zeroPoint = 0
1082 }},
1083 .operations = {{
1084 .inputs = {0, 1},
1085 .outputs = {2},
1086 .type = TestOperationType::SOFTMAX
1087 }},
1088 .outputIndexes = {2}
1089 },
1090 .minSupportedVersion = TestHalVersion::V1_2,
1091 .referenced = {}
1092 };
1093 return model;
1094 }
1095
1096 const auto dummy_test_model_float16_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_float16_dim1_axis0", get_test_model_float16_dim1_axis0());
1097
1098 } // namespace generated_tests::softmax_v1_2
1099
1100 namespace generated_tests::softmax_v1_2 {
1101
get_test_model_float16_dim1_axis0_all_inputs_as_internal()1102 const TestModel& get_test_model_float16_dim1_axis0_all_inputs_as_internal() {
1103 static TestModel model = {
1104 .expectFailure = false,
1105 .expectedMultinomialDistributionTolerance = 0,
1106 .isRelaxed = false,
1107 .main = {
1108 .inputIndexes = {3},
1109 .operands = {{ // op1
1110 .channelQuant = {},
1111 .data = TestBuffer::createFromVector<_Float16>({}),
1112 .dimensions = {5},
1113 .isIgnored = false,
1114 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1115 .numberOfConsumers = 1,
1116 .scale = 0.0f,
1117 .type = TestOperandType::TENSOR_FLOAT16,
1118 .zeroPoint = 0
1119 }, { // param
1120 .channelQuant = {},
1121 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
1122 .dimensions = {},
1123 .isIgnored = false,
1124 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1125 .numberOfConsumers = 1,
1126 .scale = 0.0f,
1127 .type = TestOperandType::FLOAT16,
1128 .zeroPoint = 0
1129 }, { // op2
1130 .channelQuant = {},
1131 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
1132 .dimensions = {5},
1133 .isIgnored = false,
1134 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1135 .numberOfConsumers = 0,
1136 .scale = 0.0f,
1137 .type = TestOperandType::TENSOR_FLOAT16,
1138 .zeroPoint = 0
1139 }, { // op1_new
1140 .channelQuant = {},
1141 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
1142 .dimensions = {5},
1143 .isIgnored = false,
1144 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1145 .numberOfConsumers = 1,
1146 .scale = 0.0f,
1147 .type = TestOperandType::TENSOR_FLOAT16,
1148 .zeroPoint = 0
1149 }, { // placeholder7
1150 .channelQuant = {},
1151 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
1152 .dimensions = {1},
1153 .isIgnored = false,
1154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1155 .numberOfConsumers = 1,
1156 .scale = 0.0f,
1157 .type = TestOperandType::TENSOR_FLOAT16,
1158 .zeroPoint = 0
1159 }, { // param25
1160 .channelQuant = {},
1161 .data = TestBuffer::createFromVector<int32_t>({0}),
1162 .dimensions = {},
1163 .isIgnored = false,
1164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1165 .numberOfConsumers = 1,
1166 .scale = 0.0f,
1167 .type = TestOperandType::INT32,
1168 .zeroPoint = 0
1169 }},
1170 .operations = {{
1171 .inputs = {3, 4, 5},
1172 .outputs = {0},
1173 .type = TestOperationType::ADD
1174 }, {
1175 .inputs = {0, 1},
1176 .outputs = {2},
1177 .type = TestOperationType::SOFTMAX
1178 }},
1179 .outputIndexes = {2}
1180 },
1181 .minSupportedVersion = TestHalVersion::V1_2,
1182 .referenced = {}
1183 };
1184 return model;
1185 }
1186
1187 const auto dummy_test_model_float16_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_float16_dim1_axis0_all_inputs_as_internal", get_test_model_float16_dim1_axis0_all_inputs_as_internal());
1188
1189 } // namespace generated_tests::softmax_v1_2
1190
1191 namespace generated_tests::softmax_v1_2 {
1192
get_test_model_float16_dim3_axis2()1193 const TestModel& get_test_model_float16_dim3_axis2() {
1194 static TestModel model = {
1195 .expectFailure = false,
1196 .expectedMultinomialDistributionTolerance = 0,
1197 .isRelaxed = false,
1198 .main = {
1199 .inputIndexes = {0},
1200 .operands = {{ // op1
1201 .channelQuant = {},
1202 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
1203 .dimensions = {2, 2, 5},
1204 .isIgnored = false,
1205 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1206 .numberOfConsumers = 1,
1207 .scale = 0.0f,
1208 .type = TestOperandType::TENSOR_FLOAT16,
1209 .zeroPoint = 0
1210 }, { // param
1211 .channelQuant = {},
1212 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
1213 .dimensions = {},
1214 .isIgnored = false,
1215 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1216 .numberOfConsumers = 1,
1217 .scale = 0.0f,
1218 .type = TestOperandType::FLOAT16,
1219 .zeroPoint = 0
1220 }, { // op2
1221 .channelQuant = {},
1222 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
1223 .dimensions = {2, 2, 5},
1224 .isIgnored = false,
1225 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1226 .numberOfConsumers = 0,
1227 .scale = 0.0f,
1228 .type = TestOperandType::TENSOR_FLOAT16,
1229 .zeroPoint = 0
1230 }},
1231 .operations = {{
1232 .inputs = {0, 1},
1233 .outputs = {2},
1234 .type = TestOperationType::SOFTMAX
1235 }},
1236 .outputIndexes = {2}
1237 },
1238 .minSupportedVersion = TestHalVersion::V1_2,
1239 .referenced = {}
1240 };
1241 return model;
1242 }
1243
1244 const auto dummy_test_model_float16_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_float16_dim3_axis2", get_test_model_float16_dim3_axis2());
1245
1246 } // namespace generated_tests::softmax_v1_2
1247
1248 namespace generated_tests::softmax_v1_2 {
1249
get_test_model_float16_dim3_axis2_all_inputs_as_internal()1250 const TestModel& get_test_model_float16_dim3_axis2_all_inputs_as_internal() {
1251 static TestModel model = {
1252 .expectFailure = false,
1253 .expectedMultinomialDistributionTolerance = 0,
1254 .isRelaxed = false,
1255 .main = {
1256 .inputIndexes = {3},
1257 .operands = {{ // op1
1258 .channelQuant = {},
1259 .data = TestBuffer::createFromVector<_Float16>({}),
1260 .dimensions = {2, 2, 5},
1261 .isIgnored = false,
1262 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1263 .numberOfConsumers = 1,
1264 .scale = 0.0f,
1265 .type = TestOperandType::TENSOR_FLOAT16,
1266 .zeroPoint = 0
1267 }, { // param
1268 .channelQuant = {},
1269 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
1270 .dimensions = {},
1271 .isIgnored = false,
1272 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1273 .numberOfConsumers = 1,
1274 .scale = 0.0f,
1275 .type = TestOperandType::FLOAT16,
1276 .zeroPoint = 0
1277 }, { // op2
1278 .channelQuant = {},
1279 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
1280 .dimensions = {2, 2, 5},
1281 .isIgnored = false,
1282 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1283 .numberOfConsumers = 0,
1284 .scale = 0.0f,
1285 .type = TestOperandType::TENSOR_FLOAT16,
1286 .zeroPoint = 0
1287 }, { // op1_new
1288 .channelQuant = {},
1289 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
1290 .dimensions = {2, 2, 5},
1291 .isIgnored = false,
1292 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1293 .numberOfConsumers = 1,
1294 .scale = 0.0f,
1295 .type = TestOperandType::TENSOR_FLOAT16,
1296 .zeroPoint = 0
1297 }, { // placeholder8
1298 .channelQuant = {},
1299 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
1300 .dimensions = {1},
1301 .isIgnored = false,
1302 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1303 .numberOfConsumers = 1,
1304 .scale = 0.0f,
1305 .type = TestOperandType::TENSOR_FLOAT16,
1306 .zeroPoint = 0
1307 }, { // param26
1308 .channelQuant = {},
1309 .data = TestBuffer::createFromVector<int32_t>({0}),
1310 .dimensions = {},
1311 .isIgnored = false,
1312 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1313 .numberOfConsumers = 1,
1314 .scale = 0.0f,
1315 .type = TestOperandType::INT32,
1316 .zeroPoint = 0
1317 }},
1318 .operations = {{
1319 .inputs = {3, 4, 5},
1320 .outputs = {0},
1321 .type = TestOperationType::ADD
1322 }, {
1323 .inputs = {0, 1},
1324 .outputs = {2},
1325 .type = TestOperationType::SOFTMAX
1326 }},
1327 .outputIndexes = {2}
1328 },
1329 .minSupportedVersion = TestHalVersion::V1_2,
1330 .referenced = {}
1331 };
1332 return model;
1333 }
1334
1335 const auto dummy_test_model_float16_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_float16_dim3_axis2_all_inputs_as_internal", get_test_model_float16_dim3_axis2_all_inputs_as_internal());
1336
1337 } // namespace generated_tests::softmax_v1_2
1338
1339 namespace generated_tests::softmax_v1_2 {
1340
get_test_model_quant8()1341 const TestModel& get_test_model_quant8() {
1342 static TestModel model = {
1343 .expectFailure = false,
1344 .expectedMultinomialDistributionTolerance = 0,
1345 .isRelaxed = false,
1346 .main = {
1347 .inputIndexes = {0},
1348 .operands = {{ // op1
1349 .channelQuant = {},
1350 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
1351 .dimensions = {2, 2, 2, 5},
1352 .isIgnored = false,
1353 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1354 .numberOfConsumers = 1,
1355 .scale = 0.25f,
1356 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1357 .zeroPoint = 128
1358 }, { // param
1359 .channelQuant = {},
1360 .data = TestBuffer::createFromVector<float>({1.0f}),
1361 .dimensions = {},
1362 .isIgnored = false,
1363 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1364 .numberOfConsumers = 1,
1365 .scale = 0.0f,
1366 .type = TestOperandType::FLOAT32,
1367 .zeroPoint = 0
1368 }, { // op2
1369 .channelQuant = {},
1370 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
1371 .dimensions = {2, 2, 2, 5},
1372 .isIgnored = false,
1373 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1374 .numberOfConsumers = 0,
1375 .scale = 0.00390625f,
1376 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1377 .zeroPoint = 0
1378 }},
1379 .operations = {{
1380 .inputs = {0, 1},
1381 .outputs = {2},
1382 .type = TestOperationType::SOFTMAX
1383 }},
1384 .outputIndexes = {2}
1385 },
1386 .minSupportedVersion = TestHalVersion::V1_0,
1387 .referenced = {}
1388 };
1389 return model;
1390 }
1391
1392 const auto dummy_test_model_quant8 = TestModelManager::get().add("softmax_v1_2_quant8", get_test_model_quant8());
1393
1394 } // namespace generated_tests::softmax_v1_2
1395
1396 namespace generated_tests::softmax_v1_2 {
1397
get_test_model_quant8_all_inputs_as_internal()1398 const TestModel& get_test_model_quant8_all_inputs_as_internal() {
1399 static TestModel model = {
1400 .expectFailure = false,
1401 .expectedMultinomialDistributionTolerance = 0,
1402 .isRelaxed = false,
1403 .main = {
1404 .inputIndexes = {3},
1405 .operands = {{ // op1
1406 .channelQuant = {},
1407 .data = TestBuffer::createFromVector<uint8_t>({}),
1408 .dimensions = {2, 2, 2, 5},
1409 .isIgnored = false,
1410 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1411 .numberOfConsumers = 1,
1412 .scale = 0.25f,
1413 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1414 .zeroPoint = 128
1415 }, { // param
1416 .channelQuant = {},
1417 .data = TestBuffer::createFromVector<float>({1.0f}),
1418 .dimensions = {},
1419 .isIgnored = false,
1420 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1421 .numberOfConsumers = 1,
1422 .scale = 0.0f,
1423 .type = TestOperandType::FLOAT32,
1424 .zeroPoint = 0
1425 }, { // op2
1426 .channelQuant = {},
1427 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
1428 .dimensions = {2, 2, 2, 5},
1429 .isIgnored = false,
1430 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1431 .numberOfConsumers = 0,
1432 .scale = 0.00390625f,
1433 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1434 .zeroPoint = 0
1435 }, { // op1_new
1436 .channelQuant = {},
1437 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
1438 .dimensions = {2, 2, 2, 5},
1439 .isIgnored = false,
1440 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1441 .numberOfConsumers = 1,
1442 .scale = 0.25f,
1443 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1444 .zeroPoint = 128
1445 }, { // placeholder9
1446 .channelQuant = {},
1447 .data = TestBuffer::createFromVector<uint8_t>({128}),
1448 .dimensions = {1},
1449 .isIgnored = false,
1450 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1451 .numberOfConsumers = 1,
1452 .scale = 0.25f,
1453 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1454 .zeroPoint = 128
1455 }, { // param27
1456 .channelQuant = {},
1457 .data = TestBuffer::createFromVector<int32_t>({0}),
1458 .dimensions = {},
1459 .isIgnored = false,
1460 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1461 .numberOfConsumers = 1,
1462 .scale = 0.0f,
1463 .type = TestOperandType::INT32,
1464 .zeroPoint = 0
1465 }},
1466 .operations = {{
1467 .inputs = {3, 4, 5},
1468 .outputs = {0},
1469 .type = TestOperationType::ADD
1470 }, {
1471 .inputs = {0, 1},
1472 .outputs = {2},
1473 .type = TestOperationType::SOFTMAX
1474 }},
1475 .outputIndexes = {2}
1476 },
1477 .minSupportedVersion = TestHalVersion::V1_0,
1478 .referenced = {}
1479 };
1480 return model;
1481 }
1482
1483 const auto dummy_test_model_quant8_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_quant8_all_inputs_as_internal", get_test_model_quant8_all_inputs_as_internal());
1484
1485 } // namespace generated_tests::softmax_v1_2
1486
1487 namespace generated_tests::softmax_v1_2 {
1488
get_test_model_quant8_dim1_axis0()1489 const TestModel& get_test_model_quant8_dim1_axis0() {
1490 static TestModel model = {
1491 .expectFailure = false,
1492 .expectedMultinomialDistributionTolerance = 0,
1493 .isRelaxed = false,
1494 .main = {
1495 .inputIndexes = {0},
1496 .operands = {{ // op1
1497 .channelQuant = {},
1498 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132}),
1499 .dimensions = {5},
1500 .isIgnored = false,
1501 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1502 .numberOfConsumers = 1,
1503 .scale = 0.25f,
1504 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1505 .zeroPoint = 128
1506 }, { // param
1507 .channelQuant = {},
1508 .data = TestBuffer::createFromVector<float>({1.0f}),
1509 .dimensions = {},
1510 .isIgnored = false,
1511 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1512 .numberOfConsumers = 1,
1513 .scale = 0.0f,
1514 .type = TestOperandType::FLOAT32,
1515 .zeroPoint = 0
1516 }, { // op2
1517 .channelQuant = {},
1518 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0}),
1519 .dimensions = {5},
1520 .isIgnored = false,
1521 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1522 .numberOfConsumers = 0,
1523 .scale = 0.00390625f,
1524 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1525 .zeroPoint = 0
1526 }},
1527 .operations = {{
1528 .inputs = {0, 1},
1529 .outputs = {2},
1530 .type = TestOperationType::SOFTMAX
1531 }},
1532 .outputIndexes = {2}
1533 },
1534 .minSupportedVersion = TestHalVersion::V1_2,
1535 .referenced = {}
1536 };
1537 return model;
1538 }
1539
1540 const auto dummy_test_model_quant8_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_quant8_dim1_axis0", get_test_model_quant8_dim1_axis0());
1541
1542 } // namespace generated_tests::softmax_v1_2
1543
1544 namespace generated_tests::softmax_v1_2 {
1545
get_test_model_quant8_dim1_axis0_all_inputs_as_internal()1546 const TestModel& get_test_model_quant8_dim1_axis0_all_inputs_as_internal() {
1547 static TestModel model = {
1548 .expectFailure = false,
1549 .expectedMultinomialDistributionTolerance = 0,
1550 .isRelaxed = false,
1551 .main = {
1552 .inputIndexes = {3},
1553 .operands = {{ // op1
1554 .channelQuant = {},
1555 .data = TestBuffer::createFromVector<uint8_t>({}),
1556 .dimensions = {5},
1557 .isIgnored = false,
1558 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1559 .numberOfConsumers = 1,
1560 .scale = 0.25f,
1561 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1562 .zeroPoint = 128
1563 }, { // param
1564 .channelQuant = {},
1565 .data = TestBuffer::createFromVector<float>({1.0f}),
1566 .dimensions = {},
1567 .isIgnored = false,
1568 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1569 .numberOfConsumers = 1,
1570 .scale = 0.0f,
1571 .type = TestOperandType::FLOAT32,
1572 .zeroPoint = 0
1573 }, { // op2
1574 .channelQuant = {},
1575 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0}),
1576 .dimensions = {5},
1577 .isIgnored = false,
1578 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1579 .numberOfConsumers = 0,
1580 .scale = 0.00390625f,
1581 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1582 .zeroPoint = 0
1583 }, { // op1_new
1584 .channelQuant = {},
1585 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132}),
1586 .dimensions = {5},
1587 .isIgnored = false,
1588 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1589 .numberOfConsumers = 1,
1590 .scale = 0.25f,
1591 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1592 .zeroPoint = 128
1593 }, { // placeholder10
1594 .channelQuant = {},
1595 .data = TestBuffer::createFromVector<uint8_t>({128}),
1596 .dimensions = {1},
1597 .isIgnored = false,
1598 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1599 .numberOfConsumers = 1,
1600 .scale = 0.25f,
1601 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1602 .zeroPoint = 128
1603 }, { // param28
1604 .channelQuant = {},
1605 .data = TestBuffer::createFromVector<int32_t>({0}),
1606 .dimensions = {},
1607 .isIgnored = false,
1608 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1609 .numberOfConsumers = 1,
1610 .scale = 0.0f,
1611 .type = TestOperandType::INT32,
1612 .zeroPoint = 0
1613 }},
1614 .operations = {{
1615 .inputs = {3, 4, 5},
1616 .outputs = {0},
1617 .type = TestOperationType::ADD
1618 }, {
1619 .inputs = {0, 1},
1620 .outputs = {2},
1621 .type = TestOperationType::SOFTMAX
1622 }},
1623 .outputIndexes = {2}
1624 },
1625 .minSupportedVersion = TestHalVersion::V1_2,
1626 .referenced = {}
1627 };
1628 return model;
1629 }
1630
1631 const auto dummy_test_model_quant8_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_quant8_dim1_axis0_all_inputs_as_internal", get_test_model_quant8_dim1_axis0_all_inputs_as_internal());
1632
1633 } // namespace generated_tests::softmax_v1_2
1634
1635 namespace generated_tests::softmax_v1_2 {
1636
get_test_model_quant8_dim3_axis2()1637 const TestModel& get_test_model_quant8_dim3_axis2() {
1638 static TestModel model = {
1639 .expectFailure = false,
1640 .expectedMultinomialDistributionTolerance = 0,
1641 .isRelaxed = false,
1642 .main = {
1643 .inputIndexes = {0},
1644 .operands = {{ // op1
1645 .channelQuant = {},
1646 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
1647 .dimensions = {2, 2, 5},
1648 .isIgnored = false,
1649 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1650 .numberOfConsumers = 1,
1651 .scale = 0.25f,
1652 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1653 .zeroPoint = 128
1654 }, { // param
1655 .channelQuant = {},
1656 .data = TestBuffer::createFromVector<float>({1.0f}),
1657 .dimensions = {},
1658 .isIgnored = false,
1659 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1660 .numberOfConsumers = 1,
1661 .scale = 0.0f,
1662 .type = TestOperandType::FLOAT32,
1663 .zeroPoint = 0
1664 }, { // op2
1665 .channelQuant = {},
1666 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
1667 .dimensions = {2, 2, 5},
1668 .isIgnored = false,
1669 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1670 .numberOfConsumers = 0,
1671 .scale = 0.00390625f,
1672 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1673 .zeroPoint = 0
1674 }},
1675 .operations = {{
1676 .inputs = {0, 1},
1677 .outputs = {2},
1678 .type = TestOperationType::SOFTMAX
1679 }},
1680 .outputIndexes = {2}
1681 },
1682 .minSupportedVersion = TestHalVersion::V1_2,
1683 .referenced = {}
1684 };
1685 return model;
1686 }
1687
1688 const auto dummy_test_model_quant8_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_quant8_dim3_axis2", get_test_model_quant8_dim3_axis2());
1689
1690 } // namespace generated_tests::softmax_v1_2
1691
1692 namespace generated_tests::softmax_v1_2 {
1693
get_test_model_quant8_dim3_axis2_all_inputs_as_internal()1694 const TestModel& get_test_model_quant8_dim3_axis2_all_inputs_as_internal() {
1695 static TestModel model = {
1696 .expectFailure = false,
1697 .expectedMultinomialDistributionTolerance = 0,
1698 .isRelaxed = false,
1699 .main = {
1700 .inputIndexes = {3},
1701 .operands = {{ // op1
1702 .channelQuant = {},
1703 .data = TestBuffer::createFromVector<uint8_t>({}),
1704 .dimensions = {2, 2, 5},
1705 .isIgnored = false,
1706 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1707 .numberOfConsumers = 1,
1708 .scale = 0.25f,
1709 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1710 .zeroPoint = 128
1711 }, { // param
1712 .channelQuant = {},
1713 .data = TestBuffer::createFromVector<float>({1.0f}),
1714 .dimensions = {},
1715 .isIgnored = false,
1716 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1717 .numberOfConsumers = 1,
1718 .scale = 0.0f,
1719 .type = TestOperandType::FLOAT32,
1720 .zeroPoint = 0
1721 }, { // op2
1722 .channelQuant = {},
1723 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
1724 .dimensions = {2, 2, 5},
1725 .isIgnored = false,
1726 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1727 .numberOfConsumers = 0,
1728 .scale = 0.00390625f,
1729 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1730 .zeroPoint = 0
1731 }, { // op1_new
1732 .channelQuant = {},
1733 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
1734 .dimensions = {2, 2, 5},
1735 .isIgnored = false,
1736 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1737 .numberOfConsumers = 1,
1738 .scale = 0.25f,
1739 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1740 .zeroPoint = 128
1741 }, { // placeholder11
1742 .channelQuant = {},
1743 .data = TestBuffer::createFromVector<uint8_t>({128}),
1744 .dimensions = {1},
1745 .isIgnored = false,
1746 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1747 .numberOfConsumers = 1,
1748 .scale = 0.25f,
1749 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1750 .zeroPoint = 128
1751 }, { // param29
1752 .channelQuant = {},
1753 .data = TestBuffer::createFromVector<int32_t>({0}),
1754 .dimensions = {},
1755 .isIgnored = false,
1756 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1757 .numberOfConsumers = 1,
1758 .scale = 0.0f,
1759 .type = TestOperandType::INT32,
1760 .zeroPoint = 0
1761 }},
1762 .operations = {{
1763 .inputs = {3, 4, 5},
1764 .outputs = {0},
1765 .type = TestOperationType::ADD
1766 }, {
1767 .inputs = {0, 1},
1768 .outputs = {2},
1769 .type = TestOperationType::SOFTMAX
1770 }},
1771 .outputIndexes = {2}
1772 },
1773 .minSupportedVersion = TestHalVersion::V1_2,
1774 .referenced = {}
1775 };
1776 return model;
1777 }
1778
1779 const auto dummy_test_model_quant8_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_quant8_dim3_axis2_all_inputs_as_internal", get_test_model_quant8_dim3_axis2_all_inputs_as_internal());
1780
1781 } // namespace generated_tests::softmax_v1_2
1782
1783 namespace generated_tests::softmax_v1_2 {
1784
get_test_model_2()1785 const TestModel& get_test_model_2() {
1786 static TestModel model = {
1787 .expectFailure = false,
1788 .expectedMultinomialDistributionTolerance = 0,
1789 .isRelaxed = false,
1790 .main = {
1791 .inputIndexes = {0},
1792 .operands = {{ // op1
1793 .channelQuant = {},
1794 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
1795 .dimensions = {2, 2, 2, 5},
1796 .isIgnored = false,
1797 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1798 .numberOfConsumers = 1,
1799 .scale = 0.0f,
1800 .type = TestOperandType::TENSOR_FLOAT32,
1801 .zeroPoint = 0
1802 }, { // param1
1803 .channelQuant = {},
1804 .data = TestBuffer::createFromVector<float>({1e-06f}),
1805 .dimensions = {},
1806 .isIgnored = false,
1807 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1808 .numberOfConsumers = 1,
1809 .scale = 0.0f,
1810 .type = TestOperandType::FLOAT32,
1811 .zeroPoint = 0
1812 }, { // op2
1813 .channelQuant = {},
1814 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
1815 .dimensions = {2, 2, 2, 5},
1816 .isIgnored = false,
1817 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1818 .numberOfConsumers = 0,
1819 .scale = 0.0f,
1820 .type = TestOperandType::TENSOR_FLOAT32,
1821 .zeroPoint = 0
1822 }},
1823 .operations = {{
1824 .inputs = {0, 1},
1825 .outputs = {2},
1826 .type = TestOperationType::SOFTMAX
1827 }},
1828 .outputIndexes = {2}
1829 },
1830 .minSupportedVersion = TestHalVersion::V1_0,
1831 .referenced = {}
1832 };
1833 return model;
1834 }
1835
1836 const auto dummy_test_model_2 = TestModelManager::get().add("softmax_v1_2_2", get_test_model_2());
1837
1838 } // namespace generated_tests::softmax_v1_2
1839
1840 namespace generated_tests::softmax_v1_2 {
1841
get_test_model_all_inputs_as_internal_2()1842 const TestModel& get_test_model_all_inputs_as_internal_2() {
1843 static TestModel model = {
1844 .expectFailure = false,
1845 .expectedMultinomialDistributionTolerance = 0,
1846 .isRelaxed = false,
1847 .main = {
1848 .inputIndexes = {3},
1849 .operands = {{ // op1
1850 .channelQuant = {},
1851 .data = TestBuffer::createFromVector<float>({}),
1852 .dimensions = {2, 2, 2, 5},
1853 .isIgnored = false,
1854 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1855 .numberOfConsumers = 1,
1856 .scale = 0.0f,
1857 .type = TestOperandType::TENSOR_FLOAT32,
1858 .zeroPoint = 0
1859 }, { // param1
1860 .channelQuant = {},
1861 .data = TestBuffer::createFromVector<float>({1e-06f}),
1862 .dimensions = {},
1863 .isIgnored = false,
1864 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1865 .numberOfConsumers = 1,
1866 .scale = 0.0f,
1867 .type = TestOperandType::FLOAT32,
1868 .zeroPoint = 0
1869 }, { // op2
1870 .channelQuant = {},
1871 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
1872 .dimensions = {2, 2, 2, 5},
1873 .isIgnored = false,
1874 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1875 .numberOfConsumers = 0,
1876 .scale = 0.0f,
1877 .type = TestOperandType::TENSOR_FLOAT32,
1878 .zeroPoint = 0
1879 }, { // op1_new
1880 .channelQuant = {},
1881 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
1882 .dimensions = {2, 2, 2, 5},
1883 .isIgnored = false,
1884 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1885 .numberOfConsumers = 1,
1886 .scale = 0.0f,
1887 .type = TestOperandType::TENSOR_FLOAT32,
1888 .zeroPoint = 0
1889 }, { // placeholder12
1890 .channelQuant = {},
1891 .data = TestBuffer::createFromVector<float>({0.0f}),
1892 .dimensions = {1},
1893 .isIgnored = false,
1894 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1895 .numberOfConsumers = 1,
1896 .scale = 0.0f,
1897 .type = TestOperandType::TENSOR_FLOAT32,
1898 .zeroPoint = 0
1899 }, { // param30
1900 .channelQuant = {},
1901 .data = TestBuffer::createFromVector<int32_t>({0}),
1902 .dimensions = {},
1903 .isIgnored = false,
1904 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1905 .numberOfConsumers = 1,
1906 .scale = 0.0f,
1907 .type = TestOperandType::INT32,
1908 .zeroPoint = 0
1909 }},
1910 .operations = {{
1911 .inputs = {3, 4, 5},
1912 .outputs = {0},
1913 .type = TestOperationType::ADD
1914 }, {
1915 .inputs = {0, 1},
1916 .outputs = {2},
1917 .type = TestOperationType::SOFTMAX
1918 }},
1919 .outputIndexes = {2}
1920 },
1921 .minSupportedVersion = TestHalVersion::V1_0,
1922 .referenced = {}
1923 };
1924 return model;
1925 }
1926
1927 const auto dummy_test_model_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_all_inputs_as_internal_2", get_test_model_all_inputs_as_internal_2());
1928
1929 } // namespace generated_tests::softmax_v1_2
1930
1931 namespace generated_tests::softmax_v1_2 {
1932
get_test_model_dim1_axis0_2()1933 const TestModel& get_test_model_dim1_axis0_2() {
1934 static TestModel model = {
1935 .expectFailure = false,
1936 .expectedMultinomialDistributionTolerance = 0,
1937 .isRelaxed = false,
1938 .main = {
1939 .inputIndexes = {0},
1940 .operands = {{ // op1
1941 .channelQuant = {},
1942 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
1943 .dimensions = {5},
1944 .isIgnored = false,
1945 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1946 .numberOfConsumers = 1,
1947 .scale = 0.0f,
1948 .type = TestOperandType::TENSOR_FLOAT32,
1949 .zeroPoint = 0
1950 }, { // param1
1951 .channelQuant = {},
1952 .data = TestBuffer::createFromVector<float>({1e-06f}),
1953 .dimensions = {},
1954 .isIgnored = false,
1955 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1956 .numberOfConsumers = 1,
1957 .scale = 0.0f,
1958 .type = TestOperandType::FLOAT32,
1959 .zeroPoint = 0
1960 }, { // op2
1961 .channelQuant = {},
1962 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
1963 .dimensions = {5},
1964 .isIgnored = false,
1965 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1966 .numberOfConsumers = 0,
1967 .scale = 0.0f,
1968 .type = TestOperandType::TENSOR_FLOAT32,
1969 .zeroPoint = 0
1970 }},
1971 .operations = {{
1972 .inputs = {0, 1},
1973 .outputs = {2},
1974 .type = TestOperationType::SOFTMAX
1975 }},
1976 .outputIndexes = {2}
1977 },
1978 .minSupportedVersion = TestHalVersion::V1_2,
1979 .referenced = {}
1980 };
1981 return model;
1982 }
1983
1984 const auto dummy_test_model_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_dim1_axis0_2", get_test_model_dim1_axis0_2());
1985
1986 } // namespace generated_tests::softmax_v1_2
1987
1988 namespace generated_tests::softmax_v1_2 {
1989
get_test_model_dim1_axis0_all_inputs_as_internal_2()1990 const TestModel& get_test_model_dim1_axis0_all_inputs_as_internal_2() {
1991 static TestModel model = {
1992 .expectFailure = false,
1993 .expectedMultinomialDistributionTolerance = 0,
1994 .isRelaxed = false,
1995 .main = {
1996 .inputIndexes = {3},
1997 .operands = {{ // op1
1998 .channelQuant = {},
1999 .data = TestBuffer::createFromVector<float>({}),
2000 .dimensions = {5},
2001 .isIgnored = false,
2002 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2003 .numberOfConsumers = 1,
2004 .scale = 0.0f,
2005 .type = TestOperandType::TENSOR_FLOAT32,
2006 .zeroPoint = 0
2007 }, { // param1
2008 .channelQuant = {},
2009 .data = TestBuffer::createFromVector<float>({1e-06f}),
2010 .dimensions = {},
2011 .isIgnored = false,
2012 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2013 .numberOfConsumers = 1,
2014 .scale = 0.0f,
2015 .type = TestOperandType::FLOAT32,
2016 .zeroPoint = 0
2017 }, { // op2
2018 .channelQuant = {},
2019 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2020 .dimensions = {5},
2021 .isIgnored = false,
2022 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2023 .numberOfConsumers = 0,
2024 .scale = 0.0f,
2025 .type = TestOperandType::TENSOR_FLOAT32,
2026 .zeroPoint = 0
2027 }, { // op1_new
2028 .channelQuant = {},
2029 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
2030 .dimensions = {5},
2031 .isIgnored = false,
2032 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2033 .numberOfConsumers = 1,
2034 .scale = 0.0f,
2035 .type = TestOperandType::TENSOR_FLOAT32,
2036 .zeroPoint = 0
2037 }, { // placeholder13
2038 .channelQuant = {},
2039 .data = TestBuffer::createFromVector<float>({0.0f}),
2040 .dimensions = {1},
2041 .isIgnored = false,
2042 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2043 .numberOfConsumers = 1,
2044 .scale = 0.0f,
2045 .type = TestOperandType::TENSOR_FLOAT32,
2046 .zeroPoint = 0
2047 }, { // param31
2048 .channelQuant = {},
2049 .data = TestBuffer::createFromVector<int32_t>({0}),
2050 .dimensions = {},
2051 .isIgnored = false,
2052 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2053 .numberOfConsumers = 1,
2054 .scale = 0.0f,
2055 .type = TestOperandType::INT32,
2056 .zeroPoint = 0
2057 }},
2058 .operations = {{
2059 .inputs = {3, 4, 5},
2060 .outputs = {0},
2061 .type = TestOperationType::ADD
2062 }, {
2063 .inputs = {0, 1},
2064 .outputs = {2},
2065 .type = TestOperationType::SOFTMAX
2066 }},
2067 .outputIndexes = {2}
2068 },
2069 .minSupportedVersion = TestHalVersion::V1_2,
2070 .referenced = {}
2071 };
2072 return model;
2073 }
2074
2075 const auto dummy_test_model_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_dim1_axis0_all_inputs_as_internal_2", get_test_model_dim1_axis0_all_inputs_as_internal_2());
2076
2077 } // namespace generated_tests::softmax_v1_2
2078
2079 namespace generated_tests::softmax_v1_2 {
2080
get_test_model_dim3_axis2_2()2081 const TestModel& get_test_model_dim3_axis2_2() {
2082 static TestModel model = {
2083 .expectFailure = false,
2084 .expectedMultinomialDistributionTolerance = 0,
2085 .isRelaxed = false,
2086 .main = {
2087 .inputIndexes = {0},
2088 .operands = {{ // op1
2089 .channelQuant = {},
2090 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2091 .dimensions = {2, 2, 5},
2092 .isIgnored = false,
2093 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2094 .numberOfConsumers = 1,
2095 .scale = 0.0f,
2096 .type = TestOperandType::TENSOR_FLOAT32,
2097 .zeroPoint = 0
2098 }, { // param1
2099 .channelQuant = {},
2100 .data = TestBuffer::createFromVector<float>({1e-06f}),
2101 .dimensions = {},
2102 .isIgnored = false,
2103 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2104 .numberOfConsumers = 1,
2105 .scale = 0.0f,
2106 .type = TestOperandType::FLOAT32,
2107 .zeroPoint = 0
2108 }, { // op2
2109 .channelQuant = {},
2110 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2111 .dimensions = {2, 2, 5},
2112 .isIgnored = false,
2113 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2114 .numberOfConsumers = 0,
2115 .scale = 0.0f,
2116 .type = TestOperandType::TENSOR_FLOAT32,
2117 .zeroPoint = 0
2118 }},
2119 .operations = {{
2120 .inputs = {0, 1},
2121 .outputs = {2},
2122 .type = TestOperationType::SOFTMAX
2123 }},
2124 .outputIndexes = {2}
2125 },
2126 .minSupportedVersion = TestHalVersion::V1_2,
2127 .referenced = {}
2128 };
2129 return model;
2130 }
2131
2132 const auto dummy_test_model_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_dim3_axis2_2", get_test_model_dim3_axis2_2());
2133
2134 } // namespace generated_tests::softmax_v1_2
2135
2136 namespace generated_tests::softmax_v1_2 {
2137
get_test_model_dim3_axis2_all_inputs_as_internal_2()2138 const TestModel& get_test_model_dim3_axis2_all_inputs_as_internal_2() {
2139 static TestModel model = {
2140 .expectFailure = false,
2141 .expectedMultinomialDistributionTolerance = 0,
2142 .isRelaxed = false,
2143 .main = {
2144 .inputIndexes = {3},
2145 .operands = {{ // op1
2146 .channelQuant = {},
2147 .data = TestBuffer::createFromVector<float>({}),
2148 .dimensions = {2, 2, 5},
2149 .isIgnored = false,
2150 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2151 .numberOfConsumers = 1,
2152 .scale = 0.0f,
2153 .type = TestOperandType::TENSOR_FLOAT32,
2154 .zeroPoint = 0
2155 }, { // param1
2156 .channelQuant = {},
2157 .data = TestBuffer::createFromVector<float>({1e-06f}),
2158 .dimensions = {},
2159 .isIgnored = false,
2160 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2161 .numberOfConsumers = 1,
2162 .scale = 0.0f,
2163 .type = TestOperandType::FLOAT32,
2164 .zeroPoint = 0
2165 }, { // op2
2166 .channelQuant = {},
2167 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2168 .dimensions = {2, 2, 5},
2169 .isIgnored = false,
2170 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2171 .numberOfConsumers = 0,
2172 .scale = 0.0f,
2173 .type = TestOperandType::TENSOR_FLOAT32,
2174 .zeroPoint = 0
2175 }, { // op1_new
2176 .channelQuant = {},
2177 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2178 .dimensions = {2, 2, 5},
2179 .isIgnored = false,
2180 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2181 .numberOfConsumers = 1,
2182 .scale = 0.0f,
2183 .type = TestOperandType::TENSOR_FLOAT32,
2184 .zeroPoint = 0
2185 }, { // placeholder14
2186 .channelQuant = {},
2187 .data = TestBuffer::createFromVector<float>({0.0f}),
2188 .dimensions = {1},
2189 .isIgnored = false,
2190 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2191 .numberOfConsumers = 1,
2192 .scale = 0.0f,
2193 .type = TestOperandType::TENSOR_FLOAT32,
2194 .zeroPoint = 0
2195 }, { // param32
2196 .channelQuant = {},
2197 .data = TestBuffer::createFromVector<int32_t>({0}),
2198 .dimensions = {},
2199 .isIgnored = false,
2200 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2201 .numberOfConsumers = 1,
2202 .scale = 0.0f,
2203 .type = TestOperandType::INT32,
2204 .zeroPoint = 0
2205 }},
2206 .operations = {{
2207 .inputs = {3, 4, 5},
2208 .outputs = {0},
2209 .type = TestOperationType::ADD
2210 }, {
2211 .inputs = {0, 1},
2212 .outputs = {2},
2213 .type = TestOperationType::SOFTMAX
2214 }},
2215 .outputIndexes = {2}
2216 },
2217 .minSupportedVersion = TestHalVersion::V1_2,
2218 .referenced = {}
2219 };
2220 return model;
2221 }
2222
2223 const auto dummy_test_model_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_dim3_axis2_all_inputs_as_internal_2", get_test_model_dim3_axis2_all_inputs_as_internal_2());
2224
2225 } // namespace generated_tests::softmax_v1_2
2226
2227 namespace generated_tests::softmax_v1_2 {
2228
get_test_model_relaxed_2()2229 const TestModel& get_test_model_relaxed_2() {
2230 static TestModel model = {
2231 .expectFailure = false,
2232 .expectedMultinomialDistributionTolerance = 0,
2233 .isRelaxed = true,
2234 .main = {
2235 .inputIndexes = {0},
2236 .operands = {{ // op1
2237 .channelQuant = {},
2238 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2239 .dimensions = {2, 2, 2, 5},
2240 .isIgnored = false,
2241 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2242 .numberOfConsumers = 1,
2243 .scale = 0.0f,
2244 .type = TestOperandType::TENSOR_FLOAT32,
2245 .zeroPoint = 0
2246 }, { // param1
2247 .channelQuant = {},
2248 .data = TestBuffer::createFromVector<float>({1e-06f}),
2249 .dimensions = {},
2250 .isIgnored = false,
2251 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2252 .numberOfConsumers = 1,
2253 .scale = 0.0f,
2254 .type = TestOperandType::FLOAT32,
2255 .zeroPoint = 0
2256 }, { // op2
2257 .channelQuant = {},
2258 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2259 .dimensions = {2, 2, 2, 5},
2260 .isIgnored = false,
2261 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2262 .numberOfConsumers = 0,
2263 .scale = 0.0f,
2264 .type = TestOperandType::TENSOR_FLOAT32,
2265 .zeroPoint = 0
2266 }},
2267 .operations = {{
2268 .inputs = {0, 1},
2269 .outputs = {2},
2270 .type = TestOperationType::SOFTMAX
2271 }},
2272 .outputIndexes = {2}
2273 },
2274 .minSupportedVersion = TestHalVersion::UNKNOWN,
2275 .referenced = {}
2276 };
2277 return model;
2278 }
2279
2280 const auto dummy_test_model_relaxed_2 = TestModelManager::get().add("softmax_v1_2_relaxed_2", get_test_model_relaxed_2());
2281
2282 } // namespace generated_tests::softmax_v1_2
2283
2284 namespace generated_tests::softmax_v1_2 {
2285
get_test_model_relaxed_all_inputs_as_internal_2()2286 const TestModel& get_test_model_relaxed_all_inputs_as_internal_2() {
2287 static TestModel model = {
2288 .expectFailure = false,
2289 .expectedMultinomialDistributionTolerance = 0,
2290 .isRelaxed = true,
2291 .main = {
2292 .inputIndexes = {3},
2293 .operands = {{ // op1
2294 .channelQuant = {},
2295 .data = TestBuffer::createFromVector<float>({}),
2296 .dimensions = {2, 2, 2, 5},
2297 .isIgnored = false,
2298 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2299 .numberOfConsumers = 1,
2300 .scale = 0.0f,
2301 .type = TestOperandType::TENSOR_FLOAT32,
2302 .zeroPoint = 0
2303 }, { // param1
2304 .channelQuant = {},
2305 .data = TestBuffer::createFromVector<float>({1e-06f}),
2306 .dimensions = {},
2307 .isIgnored = false,
2308 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2309 .numberOfConsumers = 1,
2310 .scale = 0.0f,
2311 .type = TestOperandType::FLOAT32,
2312 .zeroPoint = 0
2313 }, { // op2
2314 .channelQuant = {},
2315 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2316 .dimensions = {2, 2, 2, 5},
2317 .isIgnored = false,
2318 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2319 .numberOfConsumers = 0,
2320 .scale = 0.0f,
2321 .type = TestOperandType::TENSOR_FLOAT32,
2322 .zeroPoint = 0
2323 }, { // op1_new
2324 .channelQuant = {},
2325 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2326 .dimensions = {2, 2, 2, 5},
2327 .isIgnored = false,
2328 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2329 .numberOfConsumers = 1,
2330 .scale = 0.0f,
2331 .type = TestOperandType::TENSOR_FLOAT32,
2332 .zeroPoint = 0
2333 }, { // placeholder15
2334 .channelQuant = {},
2335 .data = TestBuffer::createFromVector<float>({0.0f}),
2336 .dimensions = {1},
2337 .isIgnored = false,
2338 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2339 .numberOfConsumers = 1,
2340 .scale = 0.0f,
2341 .type = TestOperandType::TENSOR_FLOAT32,
2342 .zeroPoint = 0
2343 }, { // param33
2344 .channelQuant = {},
2345 .data = TestBuffer::createFromVector<int32_t>({0}),
2346 .dimensions = {},
2347 .isIgnored = false,
2348 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2349 .numberOfConsumers = 1,
2350 .scale = 0.0f,
2351 .type = TestOperandType::INT32,
2352 .zeroPoint = 0
2353 }},
2354 .operations = {{
2355 .inputs = {3, 4, 5},
2356 .outputs = {0},
2357 .type = TestOperationType::ADD
2358 }, {
2359 .inputs = {0, 1},
2360 .outputs = {2},
2361 .type = TestOperationType::SOFTMAX
2362 }},
2363 .outputIndexes = {2}
2364 },
2365 .minSupportedVersion = TestHalVersion::UNKNOWN,
2366 .referenced = {}
2367 };
2368 return model;
2369 }
2370
2371 const auto dummy_test_model_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_relaxed_all_inputs_as_internal_2", get_test_model_relaxed_all_inputs_as_internal_2());
2372
2373 } // namespace generated_tests::softmax_v1_2
2374
2375 namespace generated_tests::softmax_v1_2 {
2376
get_test_model_relaxed_dim1_axis0_2()2377 const TestModel& get_test_model_relaxed_dim1_axis0_2() {
2378 static TestModel model = {
2379 .expectFailure = false,
2380 .expectedMultinomialDistributionTolerance = 0,
2381 .isRelaxed = true,
2382 .main = {
2383 .inputIndexes = {0},
2384 .operands = {{ // op1
2385 .channelQuant = {},
2386 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
2387 .dimensions = {5},
2388 .isIgnored = false,
2389 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2390 .numberOfConsumers = 1,
2391 .scale = 0.0f,
2392 .type = TestOperandType::TENSOR_FLOAT32,
2393 .zeroPoint = 0
2394 }, { // param1
2395 .channelQuant = {},
2396 .data = TestBuffer::createFromVector<float>({1e-06f}),
2397 .dimensions = {},
2398 .isIgnored = false,
2399 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2400 .numberOfConsumers = 1,
2401 .scale = 0.0f,
2402 .type = TestOperandType::FLOAT32,
2403 .zeroPoint = 0
2404 }, { // op2
2405 .channelQuant = {},
2406 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2407 .dimensions = {5},
2408 .isIgnored = false,
2409 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2410 .numberOfConsumers = 0,
2411 .scale = 0.0f,
2412 .type = TestOperandType::TENSOR_FLOAT32,
2413 .zeroPoint = 0
2414 }},
2415 .operations = {{
2416 .inputs = {0, 1},
2417 .outputs = {2},
2418 .type = TestOperationType::SOFTMAX
2419 }},
2420 .outputIndexes = {2}
2421 },
2422 .minSupportedVersion = TestHalVersion::UNKNOWN,
2423 .referenced = {}
2424 };
2425 return model;
2426 }
2427
2428 const auto dummy_test_model_relaxed_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_relaxed_dim1_axis0_2", get_test_model_relaxed_dim1_axis0_2());
2429
2430 } // namespace generated_tests::softmax_v1_2
2431
2432 namespace generated_tests::softmax_v1_2 {
2433
get_test_model_relaxed_dim1_axis0_all_inputs_as_internal_2()2434 const TestModel& get_test_model_relaxed_dim1_axis0_all_inputs_as_internal_2() {
2435 static TestModel model = {
2436 .expectFailure = false,
2437 .expectedMultinomialDistributionTolerance = 0,
2438 .isRelaxed = true,
2439 .main = {
2440 .inputIndexes = {3},
2441 .operands = {{ // op1
2442 .channelQuant = {},
2443 .data = TestBuffer::createFromVector<float>({}),
2444 .dimensions = {5},
2445 .isIgnored = false,
2446 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2447 .numberOfConsumers = 1,
2448 .scale = 0.0f,
2449 .type = TestOperandType::TENSOR_FLOAT32,
2450 .zeroPoint = 0
2451 }, { // param1
2452 .channelQuant = {},
2453 .data = TestBuffer::createFromVector<float>({1e-06f}),
2454 .dimensions = {},
2455 .isIgnored = false,
2456 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2457 .numberOfConsumers = 1,
2458 .scale = 0.0f,
2459 .type = TestOperandType::FLOAT32,
2460 .zeroPoint = 0
2461 }, { // op2
2462 .channelQuant = {},
2463 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2464 .dimensions = {5},
2465 .isIgnored = false,
2466 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2467 .numberOfConsumers = 0,
2468 .scale = 0.0f,
2469 .type = TestOperandType::TENSOR_FLOAT32,
2470 .zeroPoint = 0
2471 }, { // op1_new
2472 .channelQuant = {},
2473 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
2474 .dimensions = {5},
2475 .isIgnored = false,
2476 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2477 .numberOfConsumers = 1,
2478 .scale = 0.0f,
2479 .type = TestOperandType::TENSOR_FLOAT32,
2480 .zeroPoint = 0
2481 }, { // placeholder16
2482 .channelQuant = {},
2483 .data = TestBuffer::createFromVector<float>({0.0f}),
2484 .dimensions = {1},
2485 .isIgnored = false,
2486 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2487 .numberOfConsumers = 1,
2488 .scale = 0.0f,
2489 .type = TestOperandType::TENSOR_FLOAT32,
2490 .zeroPoint = 0
2491 }, { // param34
2492 .channelQuant = {},
2493 .data = TestBuffer::createFromVector<int32_t>({0}),
2494 .dimensions = {},
2495 .isIgnored = false,
2496 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2497 .numberOfConsumers = 1,
2498 .scale = 0.0f,
2499 .type = TestOperandType::INT32,
2500 .zeroPoint = 0
2501 }},
2502 .operations = {{
2503 .inputs = {3, 4, 5},
2504 .outputs = {0},
2505 .type = TestOperationType::ADD
2506 }, {
2507 .inputs = {0, 1},
2508 .outputs = {2},
2509 .type = TestOperationType::SOFTMAX
2510 }},
2511 .outputIndexes = {2}
2512 },
2513 .minSupportedVersion = TestHalVersion::UNKNOWN,
2514 .referenced = {}
2515 };
2516 return model;
2517 }
2518
2519 const auto dummy_test_model_relaxed_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_relaxed_dim1_axis0_all_inputs_as_internal_2", get_test_model_relaxed_dim1_axis0_all_inputs_as_internal_2());
2520
2521 } // namespace generated_tests::softmax_v1_2
2522
2523 namespace generated_tests::softmax_v1_2 {
2524
get_test_model_relaxed_dim3_axis2_2()2525 const TestModel& get_test_model_relaxed_dim3_axis2_2() {
2526 static TestModel model = {
2527 .expectFailure = false,
2528 .expectedMultinomialDistributionTolerance = 0,
2529 .isRelaxed = true,
2530 .main = {
2531 .inputIndexes = {0},
2532 .operands = {{ // op1
2533 .channelQuant = {},
2534 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2535 .dimensions = {2, 2, 5},
2536 .isIgnored = false,
2537 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2538 .numberOfConsumers = 1,
2539 .scale = 0.0f,
2540 .type = TestOperandType::TENSOR_FLOAT32,
2541 .zeroPoint = 0
2542 }, { // param1
2543 .channelQuant = {},
2544 .data = TestBuffer::createFromVector<float>({1e-06f}),
2545 .dimensions = {},
2546 .isIgnored = false,
2547 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2548 .numberOfConsumers = 1,
2549 .scale = 0.0f,
2550 .type = TestOperandType::FLOAT32,
2551 .zeroPoint = 0
2552 }, { // op2
2553 .channelQuant = {},
2554 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2555 .dimensions = {2, 2, 5},
2556 .isIgnored = false,
2557 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2558 .numberOfConsumers = 0,
2559 .scale = 0.0f,
2560 .type = TestOperandType::TENSOR_FLOAT32,
2561 .zeroPoint = 0
2562 }},
2563 .operations = {{
2564 .inputs = {0, 1},
2565 .outputs = {2},
2566 .type = TestOperationType::SOFTMAX
2567 }},
2568 .outputIndexes = {2}
2569 },
2570 .minSupportedVersion = TestHalVersion::UNKNOWN,
2571 .referenced = {}
2572 };
2573 return model;
2574 }
2575
2576 const auto dummy_test_model_relaxed_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_relaxed_dim3_axis2_2", get_test_model_relaxed_dim3_axis2_2());
2577
2578 } // namespace generated_tests::softmax_v1_2
2579
2580 namespace generated_tests::softmax_v1_2 {
2581
get_test_model_relaxed_dim3_axis2_all_inputs_as_internal_2()2582 const TestModel& get_test_model_relaxed_dim3_axis2_all_inputs_as_internal_2() {
2583 static TestModel model = {
2584 .expectFailure = false,
2585 .expectedMultinomialDistributionTolerance = 0,
2586 .isRelaxed = true,
2587 .main = {
2588 .inputIndexes = {3},
2589 .operands = {{ // op1
2590 .channelQuant = {},
2591 .data = TestBuffer::createFromVector<float>({}),
2592 .dimensions = {2, 2, 5},
2593 .isIgnored = false,
2594 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2595 .numberOfConsumers = 1,
2596 .scale = 0.0f,
2597 .type = TestOperandType::TENSOR_FLOAT32,
2598 .zeroPoint = 0
2599 }, { // param1
2600 .channelQuant = {},
2601 .data = TestBuffer::createFromVector<float>({1e-06f}),
2602 .dimensions = {},
2603 .isIgnored = false,
2604 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2605 .numberOfConsumers = 1,
2606 .scale = 0.0f,
2607 .type = TestOperandType::FLOAT32,
2608 .zeroPoint = 0
2609 }, { // op2
2610 .channelQuant = {},
2611 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
2612 .dimensions = {2, 2, 5},
2613 .isIgnored = false,
2614 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2615 .numberOfConsumers = 0,
2616 .scale = 0.0f,
2617 .type = TestOperandType::TENSOR_FLOAT32,
2618 .zeroPoint = 0
2619 }, { // op1_new
2620 .channelQuant = {},
2621 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2622 .dimensions = {2, 2, 5},
2623 .isIgnored = false,
2624 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2625 .numberOfConsumers = 1,
2626 .scale = 0.0f,
2627 .type = TestOperandType::TENSOR_FLOAT32,
2628 .zeroPoint = 0
2629 }, { // placeholder17
2630 .channelQuant = {},
2631 .data = TestBuffer::createFromVector<float>({0.0f}),
2632 .dimensions = {1},
2633 .isIgnored = false,
2634 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2635 .numberOfConsumers = 1,
2636 .scale = 0.0f,
2637 .type = TestOperandType::TENSOR_FLOAT32,
2638 .zeroPoint = 0
2639 }, { // param35
2640 .channelQuant = {},
2641 .data = TestBuffer::createFromVector<int32_t>({0}),
2642 .dimensions = {},
2643 .isIgnored = false,
2644 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2645 .numberOfConsumers = 1,
2646 .scale = 0.0f,
2647 .type = TestOperandType::INT32,
2648 .zeroPoint = 0
2649 }},
2650 .operations = {{
2651 .inputs = {3, 4, 5},
2652 .outputs = {0},
2653 .type = TestOperationType::ADD
2654 }, {
2655 .inputs = {0, 1},
2656 .outputs = {2},
2657 .type = TestOperationType::SOFTMAX
2658 }},
2659 .outputIndexes = {2}
2660 },
2661 .minSupportedVersion = TestHalVersion::UNKNOWN,
2662 .referenced = {}
2663 };
2664 return model;
2665 }
2666
2667 const auto dummy_test_model_relaxed_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_relaxed_dim3_axis2_all_inputs_as_internal_2", get_test_model_relaxed_dim3_axis2_all_inputs_as_internal_2());
2668
2669 } // namespace generated_tests::softmax_v1_2
2670
2671 namespace generated_tests::softmax_v1_2 {
2672
get_test_model_float16_2()2673 const TestModel& get_test_model_float16_2() {
2674 static TestModel model = {
2675 .expectFailure = false,
2676 .expectedMultinomialDistributionTolerance = 0,
2677 .isRelaxed = false,
2678 .main = {
2679 .inputIndexes = {0},
2680 .operands = {{ // op1
2681 .channelQuant = {},
2682 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2683 .dimensions = {2, 2, 2, 5},
2684 .isIgnored = false,
2685 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2686 .numberOfConsumers = 1,
2687 .scale = 0.0f,
2688 .type = TestOperandType::TENSOR_FLOAT16,
2689 .zeroPoint = 0
2690 }, { // param1
2691 .channelQuant = {},
2692 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
2693 .dimensions = {},
2694 .isIgnored = false,
2695 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2696 .numberOfConsumers = 1,
2697 .scale = 0.0f,
2698 .type = TestOperandType::FLOAT16,
2699 .zeroPoint = 0
2700 }, { // op2
2701 .channelQuant = {},
2702 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
2703 .dimensions = {2, 2, 2, 5},
2704 .isIgnored = false,
2705 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2706 .numberOfConsumers = 0,
2707 .scale = 0.0f,
2708 .type = TestOperandType::TENSOR_FLOAT16,
2709 .zeroPoint = 0
2710 }},
2711 .operations = {{
2712 .inputs = {0, 1},
2713 .outputs = {2},
2714 .type = TestOperationType::SOFTMAX
2715 }},
2716 .outputIndexes = {2}
2717 },
2718 .minSupportedVersion = TestHalVersion::V1_2,
2719 .referenced = {}
2720 };
2721 return model;
2722 }
2723
2724 const auto dummy_test_model_float16_2 = TestModelManager::get().add("softmax_v1_2_float16_2", get_test_model_float16_2());
2725
2726 } // namespace generated_tests::softmax_v1_2
2727
2728 namespace generated_tests::softmax_v1_2 {
2729
get_test_model_float16_all_inputs_as_internal_2()2730 const TestModel& get_test_model_float16_all_inputs_as_internal_2() {
2731 static TestModel model = {
2732 .expectFailure = false,
2733 .expectedMultinomialDistributionTolerance = 0,
2734 .isRelaxed = false,
2735 .main = {
2736 .inputIndexes = {3},
2737 .operands = {{ // op1
2738 .channelQuant = {},
2739 .data = TestBuffer::createFromVector<_Float16>({}),
2740 .dimensions = {2, 2, 2, 5},
2741 .isIgnored = false,
2742 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2743 .numberOfConsumers = 1,
2744 .scale = 0.0f,
2745 .type = TestOperandType::TENSOR_FLOAT16,
2746 .zeroPoint = 0
2747 }, { // param1
2748 .channelQuant = {},
2749 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
2750 .dimensions = {},
2751 .isIgnored = false,
2752 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2753 .numberOfConsumers = 1,
2754 .scale = 0.0f,
2755 .type = TestOperandType::FLOAT16,
2756 .zeroPoint = 0
2757 }, { // op2
2758 .channelQuant = {},
2759 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
2760 .dimensions = {2, 2, 2, 5},
2761 .isIgnored = false,
2762 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2763 .numberOfConsumers = 0,
2764 .scale = 0.0f,
2765 .type = TestOperandType::TENSOR_FLOAT16,
2766 .zeroPoint = 0
2767 }, { // op1_new
2768 .channelQuant = {},
2769 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2770 .dimensions = {2, 2, 2, 5},
2771 .isIgnored = false,
2772 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2773 .numberOfConsumers = 1,
2774 .scale = 0.0f,
2775 .type = TestOperandType::TENSOR_FLOAT16,
2776 .zeroPoint = 0
2777 }, { // placeholder18
2778 .channelQuant = {},
2779 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
2780 .dimensions = {1},
2781 .isIgnored = false,
2782 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2783 .numberOfConsumers = 1,
2784 .scale = 0.0f,
2785 .type = TestOperandType::TENSOR_FLOAT16,
2786 .zeroPoint = 0
2787 }, { // param36
2788 .channelQuant = {},
2789 .data = TestBuffer::createFromVector<int32_t>({0}),
2790 .dimensions = {},
2791 .isIgnored = false,
2792 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2793 .numberOfConsumers = 1,
2794 .scale = 0.0f,
2795 .type = TestOperandType::INT32,
2796 .zeroPoint = 0
2797 }},
2798 .operations = {{
2799 .inputs = {3, 4, 5},
2800 .outputs = {0},
2801 .type = TestOperationType::ADD
2802 }, {
2803 .inputs = {0, 1},
2804 .outputs = {2},
2805 .type = TestOperationType::SOFTMAX
2806 }},
2807 .outputIndexes = {2}
2808 },
2809 .minSupportedVersion = TestHalVersion::V1_2,
2810 .referenced = {}
2811 };
2812 return model;
2813 }
2814
2815 const auto dummy_test_model_float16_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_float16_all_inputs_as_internal_2", get_test_model_float16_all_inputs_as_internal_2());
2816
2817 } // namespace generated_tests::softmax_v1_2
2818
2819 namespace generated_tests::softmax_v1_2 {
2820
get_test_model_float16_dim1_axis0_2()2821 const TestModel& get_test_model_float16_dim1_axis0_2() {
2822 static TestModel model = {
2823 .expectFailure = false,
2824 .expectedMultinomialDistributionTolerance = 0,
2825 .isRelaxed = false,
2826 .main = {
2827 .inputIndexes = {0},
2828 .operands = {{ // op1
2829 .channelQuant = {},
2830 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
2831 .dimensions = {5},
2832 .isIgnored = false,
2833 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2834 .numberOfConsumers = 1,
2835 .scale = 0.0f,
2836 .type = TestOperandType::TENSOR_FLOAT16,
2837 .zeroPoint = 0
2838 }, { // param1
2839 .channelQuant = {},
2840 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
2841 .dimensions = {},
2842 .isIgnored = false,
2843 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2844 .numberOfConsumers = 1,
2845 .scale = 0.0f,
2846 .type = TestOperandType::FLOAT16,
2847 .zeroPoint = 0
2848 }, { // op2
2849 .channelQuant = {},
2850 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
2851 .dimensions = {5},
2852 .isIgnored = false,
2853 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2854 .numberOfConsumers = 0,
2855 .scale = 0.0f,
2856 .type = TestOperandType::TENSOR_FLOAT16,
2857 .zeroPoint = 0
2858 }},
2859 .operations = {{
2860 .inputs = {0, 1},
2861 .outputs = {2},
2862 .type = TestOperationType::SOFTMAX
2863 }},
2864 .outputIndexes = {2}
2865 },
2866 .minSupportedVersion = TestHalVersion::V1_2,
2867 .referenced = {}
2868 };
2869 return model;
2870 }
2871
2872 const auto dummy_test_model_float16_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_float16_dim1_axis0_2", get_test_model_float16_dim1_axis0_2());
2873
2874 } // namespace generated_tests::softmax_v1_2
2875
2876 namespace generated_tests::softmax_v1_2 {
2877
get_test_model_float16_dim1_axis0_all_inputs_as_internal_2()2878 const TestModel& get_test_model_float16_dim1_axis0_all_inputs_as_internal_2() {
2879 static TestModel model = {
2880 .expectFailure = false,
2881 .expectedMultinomialDistributionTolerance = 0,
2882 .isRelaxed = false,
2883 .main = {
2884 .inputIndexes = {3},
2885 .operands = {{ // op1
2886 .channelQuant = {},
2887 .data = TestBuffer::createFromVector<_Float16>({}),
2888 .dimensions = {5},
2889 .isIgnored = false,
2890 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2891 .numberOfConsumers = 1,
2892 .scale = 0.0f,
2893 .type = TestOperandType::TENSOR_FLOAT16,
2894 .zeroPoint = 0
2895 }, { // param1
2896 .channelQuant = {},
2897 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
2898 .dimensions = {},
2899 .isIgnored = false,
2900 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2901 .numberOfConsumers = 1,
2902 .scale = 0.0f,
2903 .type = TestOperandType::FLOAT16,
2904 .zeroPoint = 0
2905 }, { // op2
2906 .channelQuant = {},
2907 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
2908 .dimensions = {5},
2909 .isIgnored = false,
2910 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2911 .numberOfConsumers = 0,
2912 .scale = 0.0f,
2913 .type = TestOperandType::TENSOR_FLOAT16,
2914 .zeroPoint = 0
2915 }, { // op1_new
2916 .channelQuant = {},
2917 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
2918 .dimensions = {5},
2919 .isIgnored = false,
2920 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2921 .numberOfConsumers = 1,
2922 .scale = 0.0f,
2923 .type = TestOperandType::TENSOR_FLOAT16,
2924 .zeroPoint = 0
2925 }, { // placeholder19
2926 .channelQuant = {},
2927 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
2928 .dimensions = {1},
2929 .isIgnored = false,
2930 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2931 .numberOfConsumers = 1,
2932 .scale = 0.0f,
2933 .type = TestOperandType::TENSOR_FLOAT16,
2934 .zeroPoint = 0
2935 }, { // param37
2936 .channelQuant = {},
2937 .data = TestBuffer::createFromVector<int32_t>({0}),
2938 .dimensions = {},
2939 .isIgnored = false,
2940 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2941 .numberOfConsumers = 1,
2942 .scale = 0.0f,
2943 .type = TestOperandType::INT32,
2944 .zeroPoint = 0
2945 }},
2946 .operations = {{
2947 .inputs = {3, 4, 5},
2948 .outputs = {0},
2949 .type = TestOperationType::ADD
2950 }, {
2951 .inputs = {0, 1},
2952 .outputs = {2},
2953 .type = TestOperationType::SOFTMAX
2954 }},
2955 .outputIndexes = {2}
2956 },
2957 .minSupportedVersion = TestHalVersion::V1_2,
2958 .referenced = {}
2959 };
2960 return model;
2961 }
2962
2963 const auto dummy_test_model_float16_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_float16_dim1_axis0_all_inputs_as_internal_2", get_test_model_float16_dim1_axis0_all_inputs_as_internal_2());
2964
2965 } // namespace generated_tests::softmax_v1_2
2966
2967 namespace generated_tests::softmax_v1_2 {
2968
get_test_model_float16_dim3_axis2_2()2969 const TestModel& get_test_model_float16_dim3_axis2_2() {
2970 static TestModel model = {
2971 .expectFailure = false,
2972 .expectedMultinomialDistributionTolerance = 0,
2973 .isRelaxed = false,
2974 .main = {
2975 .inputIndexes = {0},
2976 .operands = {{ // op1
2977 .channelQuant = {},
2978 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
2979 .dimensions = {2, 2, 5},
2980 .isIgnored = false,
2981 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2982 .numberOfConsumers = 1,
2983 .scale = 0.0f,
2984 .type = TestOperandType::TENSOR_FLOAT16,
2985 .zeroPoint = 0
2986 }, { // param1
2987 .channelQuant = {},
2988 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
2989 .dimensions = {},
2990 .isIgnored = false,
2991 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2992 .numberOfConsumers = 1,
2993 .scale = 0.0f,
2994 .type = TestOperandType::FLOAT16,
2995 .zeroPoint = 0
2996 }, { // op2
2997 .channelQuant = {},
2998 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
2999 .dimensions = {2, 2, 5},
3000 .isIgnored = false,
3001 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3002 .numberOfConsumers = 0,
3003 .scale = 0.0f,
3004 .type = TestOperandType::TENSOR_FLOAT16,
3005 .zeroPoint = 0
3006 }},
3007 .operations = {{
3008 .inputs = {0, 1},
3009 .outputs = {2},
3010 .type = TestOperationType::SOFTMAX
3011 }},
3012 .outputIndexes = {2}
3013 },
3014 .minSupportedVersion = TestHalVersion::V1_2,
3015 .referenced = {}
3016 };
3017 return model;
3018 }
3019
3020 const auto dummy_test_model_float16_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_float16_dim3_axis2_2", get_test_model_float16_dim3_axis2_2());
3021
3022 } // namespace generated_tests::softmax_v1_2
3023
3024 namespace generated_tests::softmax_v1_2 {
3025
get_test_model_float16_dim3_axis2_all_inputs_as_internal_2()3026 const TestModel& get_test_model_float16_dim3_axis2_all_inputs_as_internal_2() {
3027 static TestModel model = {
3028 .expectFailure = false,
3029 .expectedMultinomialDistributionTolerance = 0,
3030 .isRelaxed = false,
3031 .main = {
3032 .inputIndexes = {3},
3033 .operands = {{ // op1
3034 .channelQuant = {},
3035 .data = TestBuffer::createFromVector<_Float16>({}),
3036 .dimensions = {2, 2, 5},
3037 .isIgnored = false,
3038 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3039 .numberOfConsumers = 1,
3040 .scale = 0.0f,
3041 .type = TestOperandType::TENSOR_FLOAT16,
3042 .zeroPoint = 0
3043 }, { // param1
3044 .channelQuant = {},
3045 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
3046 .dimensions = {},
3047 .isIgnored = false,
3048 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3049 .numberOfConsumers = 1,
3050 .scale = 0.0f,
3051 .type = TestOperandType::FLOAT16,
3052 .zeroPoint = 0
3053 }, { // op2
3054 .channelQuant = {},
3055 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
3056 .dimensions = {2, 2, 5},
3057 .isIgnored = false,
3058 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3059 .numberOfConsumers = 0,
3060 .scale = 0.0f,
3061 .type = TestOperandType::TENSOR_FLOAT16,
3062 .zeroPoint = 0
3063 }, { // op1_new
3064 .channelQuant = {},
3065 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
3066 .dimensions = {2, 2, 5},
3067 .isIgnored = false,
3068 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3069 .numberOfConsumers = 1,
3070 .scale = 0.0f,
3071 .type = TestOperandType::TENSOR_FLOAT16,
3072 .zeroPoint = 0
3073 }, { // placeholder20
3074 .channelQuant = {},
3075 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
3076 .dimensions = {1},
3077 .isIgnored = false,
3078 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3079 .numberOfConsumers = 1,
3080 .scale = 0.0f,
3081 .type = TestOperandType::TENSOR_FLOAT16,
3082 .zeroPoint = 0
3083 }, { // param38
3084 .channelQuant = {},
3085 .data = TestBuffer::createFromVector<int32_t>({0}),
3086 .dimensions = {},
3087 .isIgnored = false,
3088 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3089 .numberOfConsumers = 1,
3090 .scale = 0.0f,
3091 .type = TestOperandType::INT32,
3092 .zeroPoint = 0
3093 }},
3094 .operations = {{
3095 .inputs = {3, 4, 5},
3096 .outputs = {0},
3097 .type = TestOperationType::ADD
3098 }, {
3099 .inputs = {0, 1},
3100 .outputs = {2},
3101 .type = TestOperationType::SOFTMAX
3102 }},
3103 .outputIndexes = {2}
3104 },
3105 .minSupportedVersion = TestHalVersion::V1_2,
3106 .referenced = {}
3107 };
3108 return model;
3109 }
3110
3111 const auto dummy_test_model_float16_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_float16_dim3_axis2_all_inputs_as_internal_2", get_test_model_float16_dim3_axis2_all_inputs_as_internal_2());
3112
3113 } // namespace generated_tests::softmax_v1_2
3114
3115 namespace generated_tests::softmax_v1_2 {
3116
get_test_model_quant8_2()3117 const TestModel& get_test_model_quant8_2() {
3118 static TestModel model = {
3119 .expectFailure = false,
3120 .expectedMultinomialDistributionTolerance = 0,
3121 .isRelaxed = false,
3122 .main = {
3123 .inputIndexes = {0},
3124 .operands = {{ // op1
3125 .channelQuant = {},
3126 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
3127 .dimensions = {2, 2, 2, 5},
3128 .isIgnored = false,
3129 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3130 .numberOfConsumers = 1,
3131 .scale = 0.25f,
3132 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3133 .zeroPoint = 128
3134 }, { // param1
3135 .channelQuant = {},
3136 .data = TestBuffer::createFromVector<float>({1e-06f}),
3137 .dimensions = {},
3138 .isIgnored = false,
3139 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3140 .numberOfConsumers = 1,
3141 .scale = 0.0f,
3142 .type = TestOperandType::FLOAT32,
3143 .zeroPoint = 0
3144 }, { // op2
3145 .channelQuant = {},
3146 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
3147 .dimensions = {2, 2, 2, 5},
3148 .isIgnored = false,
3149 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3150 .numberOfConsumers = 0,
3151 .scale = 0.00390625f,
3152 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3153 .zeroPoint = 0
3154 }},
3155 .operations = {{
3156 .inputs = {0, 1},
3157 .outputs = {2},
3158 .type = TestOperationType::SOFTMAX
3159 }},
3160 .outputIndexes = {2}
3161 },
3162 .minSupportedVersion = TestHalVersion::V1_0,
3163 .referenced = {}
3164 };
3165 return model;
3166 }
3167
3168 const auto dummy_test_model_quant8_2 = TestModelManager::get().add("softmax_v1_2_quant8_2", get_test_model_quant8_2());
3169
3170 } // namespace generated_tests::softmax_v1_2
3171
3172 namespace generated_tests::softmax_v1_2 {
3173
get_test_model_quant8_all_inputs_as_internal_2()3174 const TestModel& get_test_model_quant8_all_inputs_as_internal_2() {
3175 static TestModel model = {
3176 .expectFailure = false,
3177 .expectedMultinomialDistributionTolerance = 0,
3178 .isRelaxed = false,
3179 .main = {
3180 .inputIndexes = {3},
3181 .operands = {{ // op1
3182 .channelQuant = {},
3183 .data = TestBuffer::createFromVector<uint8_t>({}),
3184 .dimensions = {2, 2, 2, 5},
3185 .isIgnored = false,
3186 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3187 .numberOfConsumers = 1,
3188 .scale = 0.25f,
3189 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3190 .zeroPoint = 128
3191 }, { // param1
3192 .channelQuant = {},
3193 .data = TestBuffer::createFromVector<float>({1e-06f}),
3194 .dimensions = {},
3195 .isIgnored = false,
3196 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3197 .numberOfConsumers = 1,
3198 .scale = 0.0f,
3199 .type = TestOperandType::FLOAT32,
3200 .zeroPoint = 0
3201 }, { // op2
3202 .channelQuant = {},
3203 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
3204 .dimensions = {2, 2, 2, 5},
3205 .isIgnored = false,
3206 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3207 .numberOfConsumers = 0,
3208 .scale = 0.00390625f,
3209 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3210 .zeroPoint = 0
3211 }, { // op1_new
3212 .channelQuant = {},
3213 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
3214 .dimensions = {2, 2, 2, 5},
3215 .isIgnored = false,
3216 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3217 .numberOfConsumers = 1,
3218 .scale = 0.25f,
3219 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3220 .zeroPoint = 128
3221 }, { // placeholder21
3222 .channelQuant = {},
3223 .data = TestBuffer::createFromVector<uint8_t>({128}),
3224 .dimensions = {1},
3225 .isIgnored = false,
3226 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3227 .numberOfConsumers = 1,
3228 .scale = 0.25f,
3229 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3230 .zeroPoint = 128
3231 }, { // param39
3232 .channelQuant = {},
3233 .data = TestBuffer::createFromVector<int32_t>({0}),
3234 .dimensions = {},
3235 .isIgnored = false,
3236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3237 .numberOfConsumers = 1,
3238 .scale = 0.0f,
3239 .type = TestOperandType::INT32,
3240 .zeroPoint = 0
3241 }},
3242 .operations = {{
3243 .inputs = {3, 4, 5},
3244 .outputs = {0},
3245 .type = TestOperationType::ADD
3246 }, {
3247 .inputs = {0, 1},
3248 .outputs = {2},
3249 .type = TestOperationType::SOFTMAX
3250 }},
3251 .outputIndexes = {2}
3252 },
3253 .minSupportedVersion = TestHalVersion::V1_0,
3254 .referenced = {}
3255 };
3256 return model;
3257 }
3258
3259 const auto dummy_test_model_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_quant8_all_inputs_as_internal_2", get_test_model_quant8_all_inputs_as_internal_2());
3260
3261 } // namespace generated_tests::softmax_v1_2
3262
3263 namespace generated_tests::softmax_v1_2 {
3264
get_test_model_quant8_dim1_axis0_2()3265 const TestModel& get_test_model_quant8_dim1_axis0_2() {
3266 static TestModel model = {
3267 .expectFailure = false,
3268 .expectedMultinomialDistributionTolerance = 0,
3269 .isRelaxed = false,
3270 .main = {
3271 .inputIndexes = {0},
3272 .operands = {{ // op1
3273 .channelQuant = {},
3274 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148}),
3275 .dimensions = {5},
3276 .isIgnored = false,
3277 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3278 .numberOfConsumers = 1,
3279 .scale = 0.25f,
3280 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3281 .zeroPoint = 128
3282 }, { // param1
3283 .channelQuant = {},
3284 .data = TestBuffer::createFromVector<float>({1e-06f}),
3285 .dimensions = {},
3286 .isIgnored = false,
3287 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3288 .numberOfConsumers = 1,
3289 .scale = 0.0f,
3290 .type = TestOperandType::FLOAT32,
3291 .zeroPoint = 0
3292 }, { // op2
3293 .channelQuant = {},
3294 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51}),
3295 .dimensions = {5},
3296 .isIgnored = false,
3297 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3298 .numberOfConsumers = 0,
3299 .scale = 0.00390625f,
3300 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3301 .zeroPoint = 0
3302 }},
3303 .operations = {{
3304 .inputs = {0, 1},
3305 .outputs = {2},
3306 .type = TestOperationType::SOFTMAX
3307 }},
3308 .outputIndexes = {2}
3309 },
3310 .minSupportedVersion = TestHalVersion::V1_2,
3311 .referenced = {}
3312 };
3313 return model;
3314 }
3315
3316 const auto dummy_test_model_quant8_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_quant8_dim1_axis0_2", get_test_model_quant8_dim1_axis0_2());
3317
3318 } // namespace generated_tests::softmax_v1_2
3319
3320 namespace generated_tests::softmax_v1_2 {
3321
get_test_model_quant8_dim1_axis0_all_inputs_as_internal_2()3322 const TestModel& get_test_model_quant8_dim1_axis0_all_inputs_as_internal_2() {
3323 static TestModel model = {
3324 .expectFailure = false,
3325 .expectedMultinomialDistributionTolerance = 0,
3326 .isRelaxed = false,
3327 .main = {
3328 .inputIndexes = {3},
3329 .operands = {{ // op1
3330 .channelQuant = {},
3331 .data = TestBuffer::createFromVector<uint8_t>({}),
3332 .dimensions = {5},
3333 .isIgnored = false,
3334 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3335 .numberOfConsumers = 1,
3336 .scale = 0.25f,
3337 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3338 .zeroPoint = 128
3339 }, { // param1
3340 .channelQuant = {},
3341 .data = TestBuffer::createFromVector<float>({1e-06f}),
3342 .dimensions = {},
3343 .isIgnored = false,
3344 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3345 .numberOfConsumers = 1,
3346 .scale = 0.0f,
3347 .type = TestOperandType::FLOAT32,
3348 .zeroPoint = 0
3349 }, { // op2
3350 .channelQuant = {},
3351 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51}),
3352 .dimensions = {5},
3353 .isIgnored = false,
3354 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3355 .numberOfConsumers = 0,
3356 .scale = 0.00390625f,
3357 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3358 .zeroPoint = 0
3359 }, { // op1_new
3360 .channelQuant = {},
3361 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148}),
3362 .dimensions = {5},
3363 .isIgnored = false,
3364 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3365 .numberOfConsumers = 1,
3366 .scale = 0.25f,
3367 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3368 .zeroPoint = 128
3369 }, { // placeholder22
3370 .channelQuant = {},
3371 .data = TestBuffer::createFromVector<uint8_t>({128}),
3372 .dimensions = {1},
3373 .isIgnored = false,
3374 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3375 .numberOfConsumers = 1,
3376 .scale = 0.25f,
3377 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3378 .zeroPoint = 128
3379 }, { // param40
3380 .channelQuant = {},
3381 .data = TestBuffer::createFromVector<int32_t>({0}),
3382 .dimensions = {},
3383 .isIgnored = false,
3384 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3385 .numberOfConsumers = 1,
3386 .scale = 0.0f,
3387 .type = TestOperandType::INT32,
3388 .zeroPoint = 0
3389 }},
3390 .operations = {{
3391 .inputs = {3, 4, 5},
3392 .outputs = {0},
3393 .type = TestOperationType::ADD
3394 }, {
3395 .inputs = {0, 1},
3396 .outputs = {2},
3397 .type = TestOperationType::SOFTMAX
3398 }},
3399 .outputIndexes = {2}
3400 },
3401 .minSupportedVersion = TestHalVersion::V1_2,
3402 .referenced = {}
3403 };
3404 return model;
3405 }
3406
3407 const auto dummy_test_model_quant8_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_quant8_dim1_axis0_all_inputs_as_internal_2", get_test_model_quant8_dim1_axis0_all_inputs_as_internal_2());
3408
3409 } // namespace generated_tests::softmax_v1_2
3410
3411 namespace generated_tests::softmax_v1_2 {
3412
get_test_model_quant8_dim3_axis2_2()3413 const TestModel& get_test_model_quant8_dim3_axis2_2() {
3414 static TestModel model = {
3415 .expectFailure = false,
3416 .expectedMultinomialDistributionTolerance = 0,
3417 .isRelaxed = false,
3418 .main = {
3419 .inputIndexes = {0},
3420 .operands = {{ // op1
3421 .channelQuant = {},
3422 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
3423 .dimensions = {2, 2, 5},
3424 .isIgnored = false,
3425 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3426 .numberOfConsumers = 1,
3427 .scale = 0.25f,
3428 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3429 .zeroPoint = 128
3430 }, { // param1
3431 .channelQuant = {},
3432 .data = TestBuffer::createFromVector<float>({1e-06f}),
3433 .dimensions = {},
3434 .isIgnored = false,
3435 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3436 .numberOfConsumers = 1,
3437 .scale = 0.0f,
3438 .type = TestOperandType::FLOAT32,
3439 .zeroPoint = 0
3440 }, { // op2
3441 .channelQuant = {},
3442 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
3443 .dimensions = {2, 2, 5},
3444 .isIgnored = false,
3445 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3446 .numberOfConsumers = 0,
3447 .scale = 0.00390625f,
3448 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3449 .zeroPoint = 0
3450 }},
3451 .operations = {{
3452 .inputs = {0, 1},
3453 .outputs = {2},
3454 .type = TestOperationType::SOFTMAX
3455 }},
3456 .outputIndexes = {2}
3457 },
3458 .minSupportedVersion = TestHalVersion::V1_2,
3459 .referenced = {}
3460 };
3461 return model;
3462 }
3463
3464 const auto dummy_test_model_quant8_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_quant8_dim3_axis2_2", get_test_model_quant8_dim3_axis2_2());
3465
3466 } // namespace generated_tests::softmax_v1_2
3467
3468 namespace generated_tests::softmax_v1_2 {
3469
get_test_model_quant8_dim3_axis2_all_inputs_as_internal_2()3470 const TestModel& get_test_model_quant8_dim3_axis2_all_inputs_as_internal_2() {
3471 static TestModel model = {
3472 .expectFailure = false,
3473 .expectedMultinomialDistributionTolerance = 0,
3474 .isRelaxed = false,
3475 .main = {
3476 .inputIndexes = {3},
3477 .operands = {{ // op1
3478 .channelQuant = {},
3479 .data = TestBuffer::createFromVector<uint8_t>({}),
3480 .dimensions = {2, 2, 5},
3481 .isIgnored = false,
3482 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3483 .numberOfConsumers = 1,
3484 .scale = 0.25f,
3485 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3486 .zeroPoint = 128
3487 }, { // param1
3488 .channelQuant = {},
3489 .data = TestBuffer::createFromVector<float>({1e-06f}),
3490 .dimensions = {},
3491 .isIgnored = false,
3492 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3493 .numberOfConsumers = 1,
3494 .scale = 0.0f,
3495 .type = TestOperandType::FLOAT32,
3496 .zeroPoint = 0
3497 }, { // op2
3498 .channelQuant = {},
3499 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
3500 .dimensions = {2, 2, 5},
3501 .isIgnored = false,
3502 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3503 .numberOfConsumers = 0,
3504 .scale = 0.00390625f,
3505 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3506 .zeroPoint = 0
3507 }, { // op1_new
3508 .channelQuant = {},
3509 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
3510 .dimensions = {2, 2, 5},
3511 .isIgnored = false,
3512 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3513 .numberOfConsumers = 1,
3514 .scale = 0.25f,
3515 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3516 .zeroPoint = 128
3517 }, { // placeholder23
3518 .channelQuant = {},
3519 .data = TestBuffer::createFromVector<uint8_t>({128}),
3520 .dimensions = {1},
3521 .isIgnored = false,
3522 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3523 .numberOfConsumers = 1,
3524 .scale = 0.25f,
3525 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3526 .zeroPoint = 128
3527 }, { // param41
3528 .channelQuant = {},
3529 .data = TestBuffer::createFromVector<int32_t>({0}),
3530 .dimensions = {},
3531 .isIgnored = false,
3532 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3533 .numberOfConsumers = 1,
3534 .scale = 0.0f,
3535 .type = TestOperandType::INT32,
3536 .zeroPoint = 0
3537 }},
3538 .operations = {{
3539 .inputs = {3, 4, 5},
3540 .outputs = {0},
3541 .type = TestOperationType::ADD
3542 }, {
3543 .inputs = {0, 1},
3544 .outputs = {2},
3545 .type = TestOperationType::SOFTMAX
3546 }},
3547 .outputIndexes = {2}
3548 },
3549 .minSupportedVersion = TestHalVersion::V1_2,
3550 .referenced = {}
3551 };
3552 return model;
3553 }
3554
3555 const auto dummy_test_model_quant8_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_quant8_dim3_axis2_all_inputs_as_internal_2", get_test_model_quant8_dim3_axis2_all_inputs_as_internal_2());
3556
3557 } // namespace generated_tests::softmax_v1_2
3558
3559 namespace generated_tests::softmax_v1_2 {
3560
get_test_model_axis_dim4_axis0()3561 const TestModel& get_test_model_axis_dim4_axis0() {
3562 static TestModel model = {
3563 .expectFailure = false,
3564 .expectedMultinomialDistributionTolerance = 0,
3565 .isRelaxed = false,
3566 .main = { // axis
3567 .inputIndexes = {0},
3568 .operands = {{ // op1
3569 .channelQuant = {},
3570 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
3571 .dimensions = {5, 2, 2, 2},
3572 .isIgnored = false,
3573 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3574 .numberOfConsumers = 1,
3575 .scale = 0.0f,
3576 .type = TestOperandType::TENSOR_FLOAT32,
3577 .zeroPoint = 0
3578 }, { // param2
3579 .channelQuant = {},
3580 .data = TestBuffer::createFromVector<float>({1.0f}),
3581 .dimensions = {},
3582 .isIgnored = false,
3583 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3584 .numberOfConsumers = 1,
3585 .scale = 0.0f,
3586 .type = TestOperandType::FLOAT32,
3587 .zeroPoint = 0
3588 }, { // axis
3589 .channelQuant = {},
3590 .data = TestBuffer::createFromVector<int32_t>({0}),
3591 .dimensions = {},
3592 .isIgnored = false,
3593 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3594 .numberOfConsumers = 1,
3595 .scale = 0.0f,
3596 .type = TestOperandType::INT32,
3597 .zeroPoint = 0
3598 }, { // op2
3599 .channelQuant = {},
3600 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
3601 .dimensions = {5, 2, 2, 2},
3602 .isIgnored = false,
3603 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3604 .numberOfConsumers = 0,
3605 .scale = 0.0f,
3606 .type = TestOperandType::TENSOR_FLOAT32,
3607 .zeroPoint = 0
3608 }},
3609 .operations = {{
3610 .inputs = {0, 1, 2},
3611 .outputs = {3},
3612 .type = TestOperationType::SOFTMAX
3613 }},
3614 .outputIndexes = {3}
3615 },
3616 .minSupportedVersion = TestHalVersion::V1_2,
3617 .referenced = {}
3618 };
3619 return model;
3620 }
3621
3622 const auto dummy_test_model_axis_dim4_axis0 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0", get_test_model_axis_dim4_axis0());
3623
3624 } // namespace generated_tests::softmax_v1_2
3625
3626 namespace generated_tests::softmax_v1_2 {
3627
get_test_model_axis_dim4_axis0_all_inputs_as_internal()3628 const TestModel& get_test_model_axis_dim4_axis0_all_inputs_as_internal() {
3629 static TestModel model = {
3630 .expectFailure = false,
3631 .expectedMultinomialDistributionTolerance = 0,
3632 .isRelaxed = false,
3633 .main = { // axis
3634 .inputIndexes = {4},
3635 .operands = {{ // op1
3636 .channelQuant = {},
3637 .data = TestBuffer::createFromVector<float>({}),
3638 .dimensions = {5, 2, 2, 2},
3639 .isIgnored = false,
3640 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3641 .numberOfConsumers = 1,
3642 .scale = 0.0f,
3643 .type = TestOperandType::TENSOR_FLOAT32,
3644 .zeroPoint = 0
3645 }, { // param2
3646 .channelQuant = {},
3647 .data = TestBuffer::createFromVector<float>({1.0f}),
3648 .dimensions = {},
3649 .isIgnored = false,
3650 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3651 .numberOfConsumers = 1,
3652 .scale = 0.0f,
3653 .type = TestOperandType::FLOAT32,
3654 .zeroPoint = 0
3655 }, { // axis
3656 .channelQuant = {},
3657 .data = TestBuffer::createFromVector<int32_t>({0}),
3658 .dimensions = {},
3659 .isIgnored = false,
3660 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3661 .numberOfConsumers = 1,
3662 .scale = 0.0f,
3663 .type = TestOperandType::INT32,
3664 .zeroPoint = 0
3665 }, { // op2
3666 .channelQuant = {},
3667 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
3668 .dimensions = {5, 2, 2, 2},
3669 .isIgnored = false,
3670 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3671 .numberOfConsumers = 0,
3672 .scale = 0.0f,
3673 .type = TestOperandType::TENSOR_FLOAT32,
3674 .zeroPoint = 0
3675 }, { // op1_new
3676 .channelQuant = {},
3677 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
3678 .dimensions = {5, 2, 2, 2},
3679 .isIgnored = false,
3680 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3681 .numberOfConsumers = 1,
3682 .scale = 0.0f,
3683 .type = TestOperandType::TENSOR_FLOAT32,
3684 .zeroPoint = 0
3685 }, { // placeholder24
3686 .channelQuant = {},
3687 .data = TestBuffer::createFromVector<float>({0.0f}),
3688 .dimensions = {1},
3689 .isIgnored = false,
3690 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3691 .numberOfConsumers = 1,
3692 .scale = 0.0f,
3693 .type = TestOperandType::TENSOR_FLOAT32,
3694 .zeroPoint = 0
3695 }, { // param42
3696 .channelQuant = {},
3697 .data = TestBuffer::createFromVector<int32_t>({0}),
3698 .dimensions = {},
3699 .isIgnored = false,
3700 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3701 .numberOfConsumers = 1,
3702 .scale = 0.0f,
3703 .type = TestOperandType::INT32,
3704 .zeroPoint = 0
3705 }},
3706 .operations = {{
3707 .inputs = {4, 5, 6},
3708 .outputs = {0},
3709 .type = TestOperationType::ADD
3710 }, {
3711 .inputs = {0, 1, 2},
3712 .outputs = {3},
3713 .type = TestOperationType::SOFTMAX
3714 }},
3715 .outputIndexes = {3}
3716 },
3717 .minSupportedVersion = TestHalVersion::V1_2,
3718 .referenced = {}
3719 };
3720 return model;
3721 }
3722
3723 const auto dummy_test_model_axis_dim4_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0_all_inputs_as_internal", get_test_model_axis_dim4_axis0_all_inputs_as_internal());
3724
3725 } // namespace generated_tests::softmax_v1_2
3726
3727 namespace generated_tests::softmax_v1_2 {
3728
get_test_model_axis_dim4_axis0_neg()3729 const TestModel& get_test_model_axis_dim4_axis0_neg() {
3730 static TestModel model = {
3731 .expectFailure = false,
3732 .expectedMultinomialDistributionTolerance = 0,
3733 .isRelaxed = false,
3734 .main = { // axis
3735 .inputIndexes = {0},
3736 .operands = {{ // op1
3737 .channelQuant = {},
3738 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
3739 .dimensions = {5, 2, 2, 2},
3740 .isIgnored = false,
3741 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3742 .numberOfConsumers = 1,
3743 .scale = 0.0f,
3744 .type = TestOperandType::TENSOR_FLOAT32,
3745 .zeroPoint = 0
3746 }, { // param2
3747 .channelQuant = {},
3748 .data = TestBuffer::createFromVector<float>({1.0f}),
3749 .dimensions = {},
3750 .isIgnored = false,
3751 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3752 .numberOfConsumers = 1,
3753 .scale = 0.0f,
3754 .type = TestOperandType::FLOAT32,
3755 .zeroPoint = 0
3756 }, { // axis
3757 .channelQuant = {},
3758 .data = TestBuffer::createFromVector<int32_t>({-4}),
3759 .dimensions = {},
3760 .isIgnored = false,
3761 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3762 .numberOfConsumers = 1,
3763 .scale = 0.0f,
3764 .type = TestOperandType::INT32,
3765 .zeroPoint = 0
3766 }, { // op2
3767 .channelQuant = {},
3768 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
3769 .dimensions = {5, 2, 2, 2},
3770 .isIgnored = false,
3771 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3772 .numberOfConsumers = 0,
3773 .scale = 0.0f,
3774 .type = TestOperandType::TENSOR_FLOAT32,
3775 .zeroPoint = 0
3776 }},
3777 .operations = {{
3778 .inputs = {0, 1, 2},
3779 .outputs = {3},
3780 .type = TestOperationType::SOFTMAX
3781 }},
3782 .outputIndexes = {3}
3783 },
3784 .minSupportedVersion = TestHalVersion::V1_2,
3785 .referenced = {}
3786 };
3787 return model;
3788 }
3789
3790 const auto dummy_test_model_axis_dim4_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0_neg", get_test_model_axis_dim4_axis0_neg());
3791
3792 } // namespace generated_tests::softmax_v1_2
3793
3794 namespace generated_tests::softmax_v1_2 {
3795
get_test_model_axis_dim4_axis0_neg_all_inputs_as_internal()3796 const TestModel& get_test_model_axis_dim4_axis0_neg_all_inputs_as_internal() {
3797 static TestModel model = {
3798 .expectFailure = false,
3799 .expectedMultinomialDistributionTolerance = 0,
3800 .isRelaxed = false,
3801 .main = { // axis
3802 .inputIndexes = {4},
3803 .operands = {{ // op1
3804 .channelQuant = {},
3805 .data = TestBuffer::createFromVector<float>({}),
3806 .dimensions = {5, 2, 2, 2},
3807 .isIgnored = false,
3808 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3809 .numberOfConsumers = 1,
3810 .scale = 0.0f,
3811 .type = TestOperandType::TENSOR_FLOAT32,
3812 .zeroPoint = 0
3813 }, { // param2
3814 .channelQuant = {},
3815 .data = TestBuffer::createFromVector<float>({1.0f}),
3816 .dimensions = {},
3817 .isIgnored = false,
3818 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3819 .numberOfConsumers = 1,
3820 .scale = 0.0f,
3821 .type = TestOperandType::FLOAT32,
3822 .zeroPoint = 0
3823 }, { // axis
3824 .channelQuant = {},
3825 .data = TestBuffer::createFromVector<int32_t>({-4}),
3826 .dimensions = {},
3827 .isIgnored = false,
3828 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3829 .numberOfConsumers = 1,
3830 .scale = 0.0f,
3831 .type = TestOperandType::INT32,
3832 .zeroPoint = 0
3833 }, { // op2
3834 .channelQuant = {},
3835 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
3836 .dimensions = {5, 2, 2, 2},
3837 .isIgnored = false,
3838 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3839 .numberOfConsumers = 0,
3840 .scale = 0.0f,
3841 .type = TestOperandType::TENSOR_FLOAT32,
3842 .zeroPoint = 0
3843 }, { // op1_new
3844 .channelQuant = {},
3845 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
3846 .dimensions = {5, 2, 2, 2},
3847 .isIgnored = false,
3848 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3849 .numberOfConsumers = 1,
3850 .scale = 0.0f,
3851 .type = TestOperandType::TENSOR_FLOAT32,
3852 .zeroPoint = 0
3853 }, { // placeholder25
3854 .channelQuant = {},
3855 .data = TestBuffer::createFromVector<float>({0.0f}),
3856 .dimensions = {1},
3857 .isIgnored = false,
3858 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3859 .numberOfConsumers = 1,
3860 .scale = 0.0f,
3861 .type = TestOperandType::TENSOR_FLOAT32,
3862 .zeroPoint = 0
3863 }, { // param43
3864 .channelQuant = {},
3865 .data = TestBuffer::createFromVector<int32_t>({0}),
3866 .dimensions = {},
3867 .isIgnored = false,
3868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3869 .numberOfConsumers = 1,
3870 .scale = 0.0f,
3871 .type = TestOperandType::INT32,
3872 .zeroPoint = 0
3873 }},
3874 .operations = {{
3875 .inputs = {4, 5, 6},
3876 .outputs = {0},
3877 .type = TestOperationType::ADD
3878 }, {
3879 .inputs = {0, 1, 2},
3880 .outputs = {3},
3881 .type = TestOperationType::SOFTMAX
3882 }},
3883 .outputIndexes = {3}
3884 },
3885 .minSupportedVersion = TestHalVersion::V1_2,
3886 .referenced = {}
3887 };
3888 return model;
3889 }
3890
3891 const auto dummy_test_model_axis_dim4_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0_neg_all_inputs_as_internal", get_test_model_axis_dim4_axis0_neg_all_inputs_as_internal());
3892
3893 } // namespace generated_tests::softmax_v1_2
3894
3895 namespace generated_tests::softmax_v1_2 {
3896
get_test_model_axis_dim4_axis1()3897 const TestModel& get_test_model_axis_dim4_axis1() {
3898 static TestModel model = {
3899 .expectFailure = false,
3900 .expectedMultinomialDistributionTolerance = 0,
3901 .isRelaxed = false,
3902 .main = { // axis
3903 .inputIndexes = {0},
3904 .operands = {{ // op1
3905 .channelQuant = {},
3906 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
3907 .dimensions = {2, 5, 2, 2},
3908 .isIgnored = false,
3909 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3910 .numberOfConsumers = 1,
3911 .scale = 0.0f,
3912 .type = TestOperandType::TENSOR_FLOAT32,
3913 .zeroPoint = 0
3914 }, { // param2
3915 .channelQuant = {},
3916 .data = TestBuffer::createFromVector<float>({1.0f}),
3917 .dimensions = {},
3918 .isIgnored = false,
3919 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3920 .numberOfConsumers = 1,
3921 .scale = 0.0f,
3922 .type = TestOperandType::FLOAT32,
3923 .zeroPoint = 0
3924 }, { // axis
3925 .channelQuant = {},
3926 .data = TestBuffer::createFromVector<int32_t>({1}),
3927 .dimensions = {},
3928 .isIgnored = false,
3929 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3930 .numberOfConsumers = 1,
3931 .scale = 0.0f,
3932 .type = TestOperandType::INT32,
3933 .zeroPoint = 0
3934 }, { // op2
3935 .channelQuant = {},
3936 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
3937 .dimensions = {2, 5, 2, 2},
3938 .isIgnored = false,
3939 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3940 .numberOfConsumers = 0,
3941 .scale = 0.0f,
3942 .type = TestOperandType::TENSOR_FLOAT32,
3943 .zeroPoint = 0
3944 }},
3945 .operations = {{
3946 .inputs = {0, 1, 2},
3947 .outputs = {3},
3948 .type = TestOperationType::SOFTMAX
3949 }},
3950 .outputIndexes = {3}
3951 },
3952 .minSupportedVersion = TestHalVersion::V1_2,
3953 .referenced = {}
3954 };
3955 return model;
3956 }
3957
3958 const auto dummy_test_model_axis_dim4_axis1 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1", get_test_model_axis_dim4_axis1());
3959
3960 } // namespace generated_tests::softmax_v1_2
3961
3962 namespace generated_tests::softmax_v1_2 {
3963
get_test_model_axis_dim4_axis1_all_inputs_as_internal()3964 const TestModel& get_test_model_axis_dim4_axis1_all_inputs_as_internal() {
3965 static TestModel model = {
3966 .expectFailure = false,
3967 .expectedMultinomialDistributionTolerance = 0,
3968 .isRelaxed = false,
3969 .main = { // axis
3970 .inputIndexes = {4},
3971 .operands = {{ // op1
3972 .channelQuant = {},
3973 .data = TestBuffer::createFromVector<float>({}),
3974 .dimensions = {2, 5, 2, 2},
3975 .isIgnored = false,
3976 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3977 .numberOfConsumers = 1,
3978 .scale = 0.0f,
3979 .type = TestOperandType::TENSOR_FLOAT32,
3980 .zeroPoint = 0
3981 }, { // param2
3982 .channelQuant = {},
3983 .data = TestBuffer::createFromVector<float>({1.0f}),
3984 .dimensions = {},
3985 .isIgnored = false,
3986 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3987 .numberOfConsumers = 1,
3988 .scale = 0.0f,
3989 .type = TestOperandType::FLOAT32,
3990 .zeroPoint = 0
3991 }, { // axis
3992 .channelQuant = {},
3993 .data = TestBuffer::createFromVector<int32_t>({1}),
3994 .dimensions = {},
3995 .isIgnored = false,
3996 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3997 .numberOfConsumers = 1,
3998 .scale = 0.0f,
3999 .type = TestOperandType::INT32,
4000 .zeroPoint = 0
4001 }, { // op2
4002 .channelQuant = {},
4003 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4004 .dimensions = {2, 5, 2, 2},
4005 .isIgnored = false,
4006 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4007 .numberOfConsumers = 0,
4008 .scale = 0.0f,
4009 .type = TestOperandType::TENSOR_FLOAT32,
4010 .zeroPoint = 0
4011 }, { // op1_new
4012 .channelQuant = {},
4013 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
4014 .dimensions = {2, 5, 2, 2},
4015 .isIgnored = false,
4016 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4017 .numberOfConsumers = 1,
4018 .scale = 0.0f,
4019 .type = TestOperandType::TENSOR_FLOAT32,
4020 .zeroPoint = 0
4021 }, { // placeholder26
4022 .channelQuant = {},
4023 .data = TestBuffer::createFromVector<float>({0.0f}),
4024 .dimensions = {1},
4025 .isIgnored = false,
4026 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4027 .numberOfConsumers = 1,
4028 .scale = 0.0f,
4029 .type = TestOperandType::TENSOR_FLOAT32,
4030 .zeroPoint = 0
4031 }, { // param44
4032 .channelQuant = {},
4033 .data = TestBuffer::createFromVector<int32_t>({0}),
4034 .dimensions = {},
4035 .isIgnored = false,
4036 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4037 .numberOfConsumers = 1,
4038 .scale = 0.0f,
4039 .type = TestOperandType::INT32,
4040 .zeroPoint = 0
4041 }},
4042 .operations = {{
4043 .inputs = {4, 5, 6},
4044 .outputs = {0},
4045 .type = TestOperationType::ADD
4046 }, {
4047 .inputs = {0, 1, 2},
4048 .outputs = {3},
4049 .type = TestOperationType::SOFTMAX
4050 }},
4051 .outputIndexes = {3}
4052 },
4053 .minSupportedVersion = TestHalVersion::V1_2,
4054 .referenced = {}
4055 };
4056 return model;
4057 }
4058
4059 const auto dummy_test_model_axis_dim4_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1_all_inputs_as_internal", get_test_model_axis_dim4_axis1_all_inputs_as_internal());
4060
4061 } // namespace generated_tests::softmax_v1_2
4062
4063 namespace generated_tests::softmax_v1_2 {
4064
get_test_model_axis_dim4_axis1_neg()4065 const TestModel& get_test_model_axis_dim4_axis1_neg() {
4066 static TestModel model = {
4067 .expectFailure = false,
4068 .expectedMultinomialDistributionTolerance = 0,
4069 .isRelaxed = false,
4070 .main = { // axis
4071 .inputIndexes = {0},
4072 .operands = {{ // op1
4073 .channelQuant = {},
4074 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
4075 .dimensions = {2, 5, 2, 2},
4076 .isIgnored = false,
4077 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4078 .numberOfConsumers = 1,
4079 .scale = 0.0f,
4080 .type = TestOperandType::TENSOR_FLOAT32,
4081 .zeroPoint = 0
4082 }, { // param2
4083 .channelQuant = {},
4084 .data = TestBuffer::createFromVector<float>({1.0f}),
4085 .dimensions = {},
4086 .isIgnored = false,
4087 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4088 .numberOfConsumers = 1,
4089 .scale = 0.0f,
4090 .type = TestOperandType::FLOAT32,
4091 .zeroPoint = 0
4092 }, { // axis
4093 .channelQuant = {},
4094 .data = TestBuffer::createFromVector<int32_t>({-3}),
4095 .dimensions = {},
4096 .isIgnored = false,
4097 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4098 .numberOfConsumers = 1,
4099 .scale = 0.0f,
4100 .type = TestOperandType::INT32,
4101 .zeroPoint = 0
4102 }, { // op2
4103 .channelQuant = {},
4104 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4105 .dimensions = {2, 5, 2, 2},
4106 .isIgnored = false,
4107 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4108 .numberOfConsumers = 0,
4109 .scale = 0.0f,
4110 .type = TestOperandType::TENSOR_FLOAT32,
4111 .zeroPoint = 0
4112 }},
4113 .operations = {{
4114 .inputs = {0, 1, 2},
4115 .outputs = {3},
4116 .type = TestOperationType::SOFTMAX
4117 }},
4118 .outputIndexes = {3}
4119 },
4120 .minSupportedVersion = TestHalVersion::V1_2,
4121 .referenced = {}
4122 };
4123 return model;
4124 }
4125
4126 const auto dummy_test_model_axis_dim4_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1_neg", get_test_model_axis_dim4_axis1_neg());
4127
4128 } // namespace generated_tests::softmax_v1_2
4129
4130 namespace generated_tests::softmax_v1_2 {
4131
get_test_model_axis_dim4_axis1_neg_all_inputs_as_internal()4132 const TestModel& get_test_model_axis_dim4_axis1_neg_all_inputs_as_internal() {
4133 static TestModel model = {
4134 .expectFailure = false,
4135 .expectedMultinomialDistributionTolerance = 0,
4136 .isRelaxed = false,
4137 .main = { // axis
4138 .inputIndexes = {4},
4139 .operands = {{ // op1
4140 .channelQuant = {},
4141 .data = TestBuffer::createFromVector<float>({}),
4142 .dimensions = {2, 5, 2, 2},
4143 .isIgnored = false,
4144 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4145 .numberOfConsumers = 1,
4146 .scale = 0.0f,
4147 .type = TestOperandType::TENSOR_FLOAT32,
4148 .zeroPoint = 0
4149 }, { // param2
4150 .channelQuant = {},
4151 .data = TestBuffer::createFromVector<float>({1.0f}),
4152 .dimensions = {},
4153 .isIgnored = false,
4154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4155 .numberOfConsumers = 1,
4156 .scale = 0.0f,
4157 .type = TestOperandType::FLOAT32,
4158 .zeroPoint = 0
4159 }, { // axis
4160 .channelQuant = {},
4161 .data = TestBuffer::createFromVector<int32_t>({-3}),
4162 .dimensions = {},
4163 .isIgnored = false,
4164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4165 .numberOfConsumers = 1,
4166 .scale = 0.0f,
4167 .type = TestOperandType::INT32,
4168 .zeroPoint = 0
4169 }, { // op2
4170 .channelQuant = {},
4171 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4172 .dimensions = {2, 5, 2, 2},
4173 .isIgnored = false,
4174 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4175 .numberOfConsumers = 0,
4176 .scale = 0.0f,
4177 .type = TestOperandType::TENSOR_FLOAT32,
4178 .zeroPoint = 0
4179 }, { // op1_new
4180 .channelQuant = {},
4181 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
4182 .dimensions = {2, 5, 2, 2},
4183 .isIgnored = false,
4184 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4185 .numberOfConsumers = 1,
4186 .scale = 0.0f,
4187 .type = TestOperandType::TENSOR_FLOAT32,
4188 .zeroPoint = 0
4189 }, { // placeholder27
4190 .channelQuant = {},
4191 .data = TestBuffer::createFromVector<float>({0.0f}),
4192 .dimensions = {1},
4193 .isIgnored = false,
4194 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4195 .numberOfConsumers = 1,
4196 .scale = 0.0f,
4197 .type = TestOperandType::TENSOR_FLOAT32,
4198 .zeroPoint = 0
4199 }, { // param45
4200 .channelQuant = {},
4201 .data = TestBuffer::createFromVector<int32_t>({0}),
4202 .dimensions = {},
4203 .isIgnored = false,
4204 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4205 .numberOfConsumers = 1,
4206 .scale = 0.0f,
4207 .type = TestOperandType::INT32,
4208 .zeroPoint = 0
4209 }},
4210 .operations = {{
4211 .inputs = {4, 5, 6},
4212 .outputs = {0},
4213 .type = TestOperationType::ADD
4214 }, {
4215 .inputs = {0, 1, 2},
4216 .outputs = {3},
4217 .type = TestOperationType::SOFTMAX
4218 }},
4219 .outputIndexes = {3}
4220 },
4221 .minSupportedVersion = TestHalVersion::V1_2,
4222 .referenced = {}
4223 };
4224 return model;
4225 }
4226
4227 const auto dummy_test_model_axis_dim4_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1_neg_all_inputs_as_internal", get_test_model_axis_dim4_axis1_neg_all_inputs_as_internal());
4228
4229 } // namespace generated_tests::softmax_v1_2
4230
4231 namespace generated_tests::softmax_v1_2 {
4232
get_test_model_axis_dim4_axis2()4233 const TestModel& get_test_model_axis_dim4_axis2() {
4234 static TestModel model = {
4235 .expectFailure = false,
4236 .expectedMultinomialDistributionTolerance = 0,
4237 .isRelaxed = false,
4238 .main = { // axis
4239 .inputIndexes = {0},
4240 .operands = {{ // op1
4241 .channelQuant = {},
4242 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
4243 .dimensions = {2, 2, 5, 2},
4244 .isIgnored = false,
4245 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4246 .numberOfConsumers = 1,
4247 .scale = 0.0f,
4248 .type = TestOperandType::TENSOR_FLOAT32,
4249 .zeroPoint = 0
4250 }, { // param2
4251 .channelQuant = {},
4252 .data = TestBuffer::createFromVector<float>({1.0f}),
4253 .dimensions = {},
4254 .isIgnored = false,
4255 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4256 .numberOfConsumers = 1,
4257 .scale = 0.0f,
4258 .type = TestOperandType::FLOAT32,
4259 .zeroPoint = 0
4260 }, { // axis
4261 .channelQuant = {},
4262 .data = TestBuffer::createFromVector<int32_t>({2}),
4263 .dimensions = {},
4264 .isIgnored = false,
4265 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4266 .numberOfConsumers = 1,
4267 .scale = 0.0f,
4268 .type = TestOperandType::INT32,
4269 .zeroPoint = 0
4270 }, { // op2
4271 .channelQuant = {},
4272 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4273 .dimensions = {2, 2, 5, 2},
4274 .isIgnored = false,
4275 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4276 .numberOfConsumers = 0,
4277 .scale = 0.0f,
4278 .type = TestOperandType::TENSOR_FLOAT32,
4279 .zeroPoint = 0
4280 }},
4281 .operations = {{
4282 .inputs = {0, 1, 2},
4283 .outputs = {3},
4284 .type = TestOperationType::SOFTMAX
4285 }},
4286 .outputIndexes = {3}
4287 },
4288 .minSupportedVersion = TestHalVersion::V1_2,
4289 .referenced = {}
4290 };
4291 return model;
4292 }
4293
4294 const auto dummy_test_model_axis_dim4_axis2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2", get_test_model_axis_dim4_axis2());
4295
4296 } // namespace generated_tests::softmax_v1_2
4297
4298 namespace generated_tests::softmax_v1_2 {
4299
get_test_model_axis_dim4_axis2_all_inputs_as_internal()4300 const TestModel& get_test_model_axis_dim4_axis2_all_inputs_as_internal() {
4301 static TestModel model = {
4302 .expectFailure = false,
4303 .expectedMultinomialDistributionTolerance = 0,
4304 .isRelaxed = false,
4305 .main = { // axis
4306 .inputIndexes = {4},
4307 .operands = {{ // op1
4308 .channelQuant = {},
4309 .data = TestBuffer::createFromVector<float>({}),
4310 .dimensions = {2, 2, 5, 2},
4311 .isIgnored = false,
4312 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4313 .numberOfConsumers = 1,
4314 .scale = 0.0f,
4315 .type = TestOperandType::TENSOR_FLOAT32,
4316 .zeroPoint = 0
4317 }, { // param2
4318 .channelQuant = {},
4319 .data = TestBuffer::createFromVector<float>({1.0f}),
4320 .dimensions = {},
4321 .isIgnored = false,
4322 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4323 .numberOfConsumers = 1,
4324 .scale = 0.0f,
4325 .type = TestOperandType::FLOAT32,
4326 .zeroPoint = 0
4327 }, { // axis
4328 .channelQuant = {},
4329 .data = TestBuffer::createFromVector<int32_t>({2}),
4330 .dimensions = {},
4331 .isIgnored = false,
4332 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4333 .numberOfConsumers = 1,
4334 .scale = 0.0f,
4335 .type = TestOperandType::INT32,
4336 .zeroPoint = 0
4337 }, { // op2
4338 .channelQuant = {},
4339 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4340 .dimensions = {2, 2, 5, 2},
4341 .isIgnored = false,
4342 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4343 .numberOfConsumers = 0,
4344 .scale = 0.0f,
4345 .type = TestOperandType::TENSOR_FLOAT32,
4346 .zeroPoint = 0
4347 }, { // op1_new
4348 .channelQuant = {},
4349 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
4350 .dimensions = {2, 2, 5, 2},
4351 .isIgnored = false,
4352 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4353 .numberOfConsumers = 1,
4354 .scale = 0.0f,
4355 .type = TestOperandType::TENSOR_FLOAT32,
4356 .zeroPoint = 0
4357 }, { // placeholder28
4358 .channelQuant = {},
4359 .data = TestBuffer::createFromVector<float>({0.0f}),
4360 .dimensions = {1},
4361 .isIgnored = false,
4362 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4363 .numberOfConsumers = 1,
4364 .scale = 0.0f,
4365 .type = TestOperandType::TENSOR_FLOAT32,
4366 .zeroPoint = 0
4367 }, { // param46
4368 .channelQuant = {},
4369 .data = TestBuffer::createFromVector<int32_t>({0}),
4370 .dimensions = {},
4371 .isIgnored = false,
4372 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4373 .numberOfConsumers = 1,
4374 .scale = 0.0f,
4375 .type = TestOperandType::INT32,
4376 .zeroPoint = 0
4377 }},
4378 .operations = {{
4379 .inputs = {4, 5, 6},
4380 .outputs = {0},
4381 .type = TestOperationType::ADD
4382 }, {
4383 .inputs = {0, 1, 2},
4384 .outputs = {3},
4385 .type = TestOperationType::SOFTMAX
4386 }},
4387 .outputIndexes = {3}
4388 },
4389 .minSupportedVersion = TestHalVersion::V1_2,
4390 .referenced = {}
4391 };
4392 return model;
4393 }
4394
4395 const auto dummy_test_model_axis_dim4_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2_all_inputs_as_internal", get_test_model_axis_dim4_axis2_all_inputs_as_internal());
4396
4397 } // namespace generated_tests::softmax_v1_2
4398
4399 namespace generated_tests::softmax_v1_2 {
4400
get_test_model_axis_dim4_axis2_neg()4401 const TestModel& get_test_model_axis_dim4_axis2_neg() {
4402 static TestModel model = {
4403 .expectFailure = false,
4404 .expectedMultinomialDistributionTolerance = 0,
4405 .isRelaxed = false,
4406 .main = { // axis
4407 .inputIndexes = {0},
4408 .operands = {{ // op1
4409 .channelQuant = {},
4410 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
4411 .dimensions = {2, 2, 5, 2},
4412 .isIgnored = false,
4413 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4414 .numberOfConsumers = 1,
4415 .scale = 0.0f,
4416 .type = TestOperandType::TENSOR_FLOAT32,
4417 .zeroPoint = 0
4418 }, { // param2
4419 .channelQuant = {},
4420 .data = TestBuffer::createFromVector<float>({1.0f}),
4421 .dimensions = {},
4422 .isIgnored = false,
4423 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4424 .numberOfConsumers = 1,
4425 .scale = 0.0f,
4426 .type = TestOperandType::FLOAT32,
4427 .zeroPoint = 0
4428 }, { // axis
4429 .channelQuant = {},
4430 .data = TestBuffer::createFromVector<int32_t>({-2}),
4431 .dimensions = {},
4432 .isIgnored = false,
4433 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4434 .numberOfConsumers = 1,
4435 .scale = 0.0f,
4436 .type = TestOperandType::INT32,
4437 .zeroPoint = 0
4438 }, { // op2
4439 .channelQuant = {},
4440 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4441 .dimensions = {2, 2, 5, 2},
4442 .isIgnored = false,
4443 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4444 .numberOfConsumers = 0,
4445 .scale = 0.0f,
4446 .type = TestOperandType::TENSOR_FLOAT32,
4447 .zeroPoint = 0
4448 }},
4449 .operations = {{
4450 .inputs = {0, 1, 2},
4451 .outputs = {3},
4452 .type = TestOperationType::SOFTMAX
4453 }},
4454 .outputIndexes = {3}
4455 },
4456 .minSupportedVersion = TestHalVersion::V1_2,
4457 .referenced = {}
4458 };
4459 return model;
4460 }
4461
4462 const auto dummy_test_model_axis_dim4_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2_neg", get_test_model_axis_dim4_axis2_neg());
4463
4464 } // namespace generated_tests::softmax_v1_2
4465
4466 namespace generated_tests::softmax_v1_2 {
4467
get_test_model_axis_dim4_axis2_neg_all_inputs_as_internal()4468 const TestModel& get_test_model_axis_dim4_axis2_neg_all_inputs_as_internal() {
4469 static TestModel model = {
4470 .expectFailure = false,
4471 .expectedMultinomialDistributionTolerance = 0,
4472 .isRelaxed = false,
4473 .main = { // axis
4474 .inputIndexes = {4},
4475 .operands = {{ // op1
4476 .channelQuant = {},
4477 .data = TestBuffer::createFromVector<float>({}),
4478 .dimensions = {2, 2, 5, 2},
4479 .isIgnored = false,
4480 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4481 .numberOfConsumers = 1,
4482 .scale = 0.0f,
4483 .type = TestOperandType::TENSOR_FLOAT32,
4484 .zeroPoint = 0
4485 }, { // param2
4486 .channelQuant = {},
4487 .data = TestBuffer::createFromVector<float>({1.0f}),
4488 .dimensions = {},
4489 .isIgnored = false,
4490 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4491 .numberOfConsumers = 1,
4492 .scale = 0.0f,
4493 .type = TestOperandType::FLOAT32,
4494 .zeroPoint = 0
4495 }, { // axis
4496 .channelQuant = {},
4497 .data = TestBuffer::createFromVector<int32_t>({-2}),
4498 .dimensions = {},
4499 .isIgnored = false,
4500 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4501 .numberOfConsumers = 1,
4502 .scale = 0.0f,
4503 .type = TestOperandType::INT32,
4504 .zeroPoint = 0
4505 }, { // op2
4506 .channelQuant = {},
4507 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4508 .dimensions = {2, 2, 5, 2},
4509 .isIgnored = false,
4510 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4511 .numberOfConsumers = 0,
4512 .scale = 0.0f,
4513 .type = TestOperandType::TENSOR_FLOAT32,
4514 .zeroPoint = 0
4515 }, { // op1_new
4516 .channelQuant = {},
4517 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
4518 .dimensions = {2, 2, 5, 2},
4519 .isIgnored = false,
4520 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4521 .numberOfConsumers = 1,
4522 .scale = 0.0f,
4523 .type = TestOperandType::TENSOR_FLOAT32,
4524 .zeroPoint = 0
4525 }, { // placeholder29
4526 .channelQuant = {},
4527 .data = TestBuffer::createFromVector<float>({0.0f}),
4528 .dimensions = {1},
4529 .isIgnored = false,
4530 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4531 .numberOfConsumers = 1,
4532 .scale = 0.0f,
4533 .type = TestOperandType::TENSOR_FLOAT32,
4534 .zeroPoint = 0
4535 }, { // param47
4536 .channelQuant = {},
4537 .data = TestBuffer::createFromVector<int32_t>({0}),
4538 .dimensions = {},
4539 .isIgnored = false,
4540 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4541 .numberOfConsumers = 1,
4542 .scale = 0.0f,
4543 .type = TestOperandType::INT32,
4544 .zeroPoint = 0
4545 }},
4546 .operations = {{
4547 .inputs = {4, 5, 6},
4548 .outputs = {0},
4549 .type = TestOperationType::ADD
4550 }, {
4551 .inputs = {0, 1, 2},
4552 .outputs = {3},
4553 .type = TestOperationType::SOFTMAX
4554 }},
4555 .outputIndexes = {3}
4556 },
4557 .minSupportedVersion = TestHalVersion::V1_2,
4558 .referenced = {}
4559 };
4560 return model;
4561 }
4562
4563 const auto dummy_test_model_axis_dim4_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2_neg_all_inputs_as_internal", get_test_model_axis_dim4_axis2_neg_all_inputs_as_internal());
4564
4565 } // namespace generated_tests::softmax_v1_2
4566
4567 namespace generated_tests::softmax_v1_2 {
4568
get_test_model_axis_dim4_axis3()4569 const TestModel& get_test_model_axis_dim4_axis3() {
4570 static TestModel model = {
4571 .expectFailure = false,
4572 .expectedMultinomialDistributionTolerance = 0,
4573 .isRelaxed = false,
4574 .main = { // axis
4575 .inputIndexes = {0},
4576 .operands = {{ // op1
4577 .channelQuant = {},
4578 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
4579 .dimensions = {2, 2, 2, 5},
4580 .isIgnored = false,
4581 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4582 .numberOfConsumers = 1,
4583 .scale = 0.0f,
4584 .type = TestOperandType::TENSOR_FLOAT32,
4585 .zeroPoint = 0
4586 }, { // param2
4587 .channelQuant = {},
4588 .data = TestBuffer::createFromVector<float>({1.0f}),
4589 .dimensions = {},
4590 .isIgnored = false,
4591 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4592 .numberOfConsumers = 1,
4593 .scale = 0.0f,
4594 .type = TestOperandType::FLOAT32,
4595 .zeroPoint = 0
4596 }, { // axis
4597 .channelQuant = {},
4598 .data = TestBuffer::createFromVector<int32_t>({3}),
4599 .dimensions = {},
4600 .isIgnored = false,
4601 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4602 .numberOfConsumers = 1,
4603 .scale = 0.0f,
4604 .type = TestOperandType::INT32,
4605 .zeroPoint = 0
4606 }, { // op2
4607 .channelQuant = {},
4608 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
4609 .dimensions = {2, 2, 2, 5},
4610 .isIgnored = false,
4611 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4612 .numberOfConsumers = 0,
4613 .scale = 0.0f,
4614 .type = TestOperandType::TENSOR_FLOAT32,
4615 .zeroPoint = 0
4616 }},
4617 .operations = {{
4618 .inputs = {0, 1, 2},
4619 .outputs = {3},
4620 .type = TestOperationType::SOFTMAX
4621 }},
4622 .outputIndexes = {3}
4623 },
4624 .minSupportedVersion = TestHalVersion::V1_2,
4625 .referenced = {}
4626 };
4627 return model;
4628 }
4629
4630 const auto dummy_test_model_axis_dim4_axis3 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3", get_test_model_axis_dim4_axis3());
4631
4632 } // namespace generated_tests::softmax_v1_2
4633
4634 namespace generated_tests::softmax_v1_2 {
4635
get_test_model_axis_dim4_axis3_all_inputs_as_internal()4636 const TestModel& get_test_model_axis_dim4_axis3_all_inputs_as_internal() {
4637 static TestModel model = {
4638 .expectFailure = false,
4639 .expectedMultinomialDistributionTolerance = 0,
4640 .isRelaxed = false,
4641 .main = { // axis
4642 .inputIndexes = {4},
4643 .operands = {{ // op1
4644 .channelQuant = {},
4645 .data = TestBuffer::createFromVector<float>({}),
4646 .dimensions = {2, 2, 2, 5},
4647 .isIgnored = false,
4648 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4649 .numberOfConsumers = 1,
4650 .scale = 0.0f,
4651 .type = TestOperandType::TENSOR_FLOAT32,
4652 .zeroPoint = 0
4653 }, { // param2
4654 .channelQuant = {},
4655 .data = TestBuffer::createFromVector<float>({1.0f}),
4656 .dimensions = {},
4657 .isIgnored = false,
4658 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4659 .numberOfConsumers = 1,
4660 .scale = 0.0f,
4661 .type = TestOperandType::FLOAT32,
4662 .zeroPoint = 0
4663 }, { // axis
4664 .channelQuant = {},
4665 .data = TestBuffer::createFromVector<int32_t>({3}),
4666 .dimensions = {},
4667 .isIgnored = false,
4668 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4669 .numberOfConsumers = 1,
4670 .scale = 0.0f,
4671 .type = TestOperandType::INT32,
4672 .zeroPoint = 0
4673 }, { // op2
4674 .channelQuant = {},
4675 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
4676 .dimensions = {2, 2, 2, 5},
4677 .isIgnored = false,
4678 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4679 .numberOfConsumers = 0,
4680 .scale = 0.0f,
4681 .type = TestOperandType::TENSOR_FLOAT32,
4682 .zeroPoint = 0
4683 }, { // op1_new
4684 .channelQuant = {},
4685 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
4686 .dimensions = {2, 2, 2, 5},
4687 .isIgnored = false,
4688 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4689 .numberOfConsumers = 1,
4690 .scale = 0.0f,
4691 .type = TestOperandType::TENSOR_FLOAT32,
4692 .zeroPoint = 0
4693 }, { // placeholder30
4694 .channelQuant = {},
4695 .data = TestBuffer::createFromVector<float>({0.0f}),
4696 .dimensions = {1},
4697 .isIgnored = false,
4698 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4699 .numberOfConsumers = 1,
4700 .scale = 0.0f,
4701 .type = TestOperandType::TENSOR_FLOAT32,
4702 .zeroPoint = 0
4703 }, { // param48
4704 .channelQuant = {},
4705 .data = TestBuffer::createFromVector<int32_t>({0}),
4706 .dimensions = {},
4707 .isIgnored = false,
4708 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4709 .numberOfConsumers = 1,
4710 .scale = 0.0f,
4711 .type = TestOperandType::INT32,
4712 .zeroPoint = 0
4713 }},
4714 .operations = {{
4715 .inputs = {4, 5, 6},
4716 .outputs = {0},
4717 .type = TestOperationType::ADD
4718 }, {
4719 .inputs = {0, 1, 2},
4720 .outputs = {3},
4721 .type = TestOperationType::SOFTMAX
4722 }},
4723 .outputIndexes = {3}
4724 },
4725 .minSupportedVersion = TestHalVersion::V1_2,
4726 .referenced = {}
4727 };
4728 return model;
4729 }
4730
4731 const auto dummy_test_model_axis_dim4_axis3_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3_all_inputs_as_internal", get_test_model_axis_dim4_axis3_all_inputs_as_internal());
4732
4733 } // namespace generated_tests::softmax_v1_2
4734
4735 namespace generated_tests::softmax_v1_2 {
4736
get_test_model_axis_dim4_axis3_neg()4737 const TestModel& get_test_model_axis_dim4_axis3_neg() {
4738 static TestModel model = {
4739 .expectFailure = false,
4740 .expectedMultinomialDistributionTolerance = 0,
4741 .isRelaxed = false,
4742 .main = { // axis
4743 .inputIndexes = {0},
4744 .operands = {{ // op1
4745 .channelQuant = {},
4746 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
4747 .dimensions = {2, 2, 2, 5},
4748 .isIgnored = false,
4749 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4750 .numberOfConsumers = 1,
4751 .scale = 0.0f,
4752 .type = TestOperandType::TENSOR_FLOAT32,
4753 .zeroPoint = 0
4754 }, { // param2
4755 .channelQuant = {},
4756 .data = TestBuffer::createFromVector<float>({1.0f}),
4757 .dimensions = {},
4758 .isIgnored = false,
4759 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4760 .numberOfConsumers = 1,
4761 .scale = 0.0f,
4762 .type = TestOperandType::FLOAT32,
4763 .zeroPoint = 0
4764 }, { // axis
4765 .channelQuant = {},
4766 .data = TestBuffer::createFromVector<int32_t>({-1}),
4767 .dimensions = {},
4768 .isIgnored = false,
4769 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4770 .numberOfConsumers = 1,
4771 .scale = 0.0f,
4772 .type = TestOperandType::INT32,
4773 .zeroPoint = 0
4774 }, { // op2
4775 .channelQuant = {},
4776 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
4777 .dimensions = {2, 2, 2, 5},
4778 .isIgnored = false,
4779 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4780 .numberOfConsumers = 0,
4781 .scale = 0.0f,
4782 .type = TestOperandType::TENSOR_FLOAT32,
4783 .zeroPoint = 0
4784 }},
4785 .operations = {{
4786 .inputs = {0, 1, 2},
4787 .outputs = {3},
4788 .type = TestOperationType::SOFTMAX
4789 }},
4790 .outputIndexes = {3}
4791 },
4792 .minSupportedVersion = TestHalVersion::V1_0,
4793 .referenced = {}
4794 };
4795 return model;
4796 }
4797
4798 const auto dummy_test_model_axis_dim4_axis3_neg = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3_neg", get_test_model_axis_dim4_axis3_neg());
4799
4800 } // namespace generated_tests::softmax_v1_2
4801
4802 namespace generated_tests::softmax_v1_2 {
4803
get_test_model_axis_dim4_axis3_neg_all_inputs_as_internal()4804 const TestModel& get_test_model_axis_dim4_axis3_neg_all_inputs_as_internal() {
4805 static TestModel model = {
4806 .expectFailure = false,
4807 .expectedMultinomialDistributionTolerance = 0,
4808 .isRelaxed = false,
4809 .main = { // axis
4810 .inputIndexes = {4},
4811 .operands = {{ // op1
4812 .channelQuant = {},
4813 .data = TestBuffer::createFromVector<float>({}),
4814 .dimensions = {2, 2, 2, 5},
4815 .isIgnored = false,
4816 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4817 .numberOfConsumers = 1,
4818 .scale = 0.0f,
4819 .type = TestOperandType::TENSOR_FLOAT32,
4820 .zeroPoint = 0
4821 }, { // param2
4822 .channelQuant = {},
4823 .data = TestBuffer::createFromVector<float>({1.0f}),
4824 .dimensions = {},
4825 .isIgnored = false,
4826 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4827 .numberOfConsumers = 1,
4828 .scale = 0.0f,
4829 .type = TestOperandType::FLOAT32,
4830 .zeroPoint = 0
4831 }, { // axis
4832 .channelQuant = {},
4833 .data = TestBuffer::createFromVector<int32_t>({-1}),
4834 .dimensions = {},
4835 .isIgnored = false,
4836 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4837 .numberOfConsumers = 1,
4838 .scale = 0.0f,
4839 .type = TestOperandType::INT32,
4840 .zeroPoint = 0
4841 }, { // op2
4842 .channelQuant = {},
4843 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
4844 .dimensions = {2, 2, 2, 5},
4845 .isIgnored = false,
4846 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4847 .numberOfConsumers = 0,
4848 .scale = 0.0f,
4849 .type = TestOperandType::TENSOR_FLOAT32,
4850 .zeroPoint = 0
4851 }, { // op1_new
4852 .channelQuant = {},
4853 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
4854 .dimensions = {2, 2, 2, 5},
4855 .isIgnored = false,
4856 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4857 .numberOfConsumers = 1,
4858 .scale = 0.0f,
4859 .type = TestOperandType::TENSOR_FLOAT32,
4860 .zeroPoint = 0
4861 }, { // placeholder31
4862 .channelQuant = {},
4863 .data = TestBuffer::createFromVector<float>({0.0f}),
4864 .dimensions = {1},
4865 .isIgnored = false,
4866 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4867 .numberOfConsumers = 1,
4868 .scale = 0.0f,
4869 .type = TestOperandType::TENSOR_FLOAT32,
4870 .zeroPoint = 0
4871 }, { // param49
4872 .channelQuant = {},
4873 .data = TestBuffer::createFromVector<int32_t>({0}),
4874 .dimensions = {},
4875 .isIgnored = false,
4876 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4877 .numberOfConsumers = 1,
4878 .scale = 0.0f,
4879 .type = TestOperandType::INT32,
4880 .zeroPoint = 0
4881 }},
4882 .operations = {{
4883 .inputs = {4, 5, 6},
4884 .outputs = {0},
4885 .type = TestOperationType::ADD
4886 }, {
4887 .inputs = {0, 1, 2},
4888 .outputs = {3},
4889 .type = TestOperationType::SOFTMAX
4890 }},
4891 .outputIndexes = {3}
4892 },
4893 .minSupportedVersion = TestHalVersion::V1_0,
4894 .referenced = {}
4895 };
4896 return model;
4897 }
4898
4899 const auto dummy_test_model_axis_dim4_axis3_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3_neg_all_inputs_as_internal", get_test_model_axis_dim4_axis3_neg_all_inputs_as_internal());
4900
4901 } // namespace generated_tests::softmax_v1_2
4902
4903 namespace generated_tests::softmax_v1_2 {
4904
get_test_model_axis_dim3_axis0()4905 const TestModel& get_test_model_axis_dim3_axis0() {
4906 static TestModel model = {
4907 .expectFailure = false,
4908 .expectedMultinomialDistributionTolerance = 0,
4909 .isRelaxed = false,
4910 .main = { // axis
4911 .inputIndexes = {0},
4912 .operands = {{ // op1
4913 .channelQuant = {},
4914 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
4915 .dimensions = {5, 2, 2},
4916 .isIgnored = false,
4917 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4918 .numberOfConsumers = 1,
4919 .scale = 0.0f,
4920 .type = TestOperandType::TENSOR_FLOAT32,
4921 .zeroPoint = 0
4922 }, { // param2
4923 .channelQuant = {},
4924 .data = TestBuffer::createFromVector<float>({1.0f}),
4925 .dimensions = {},
4926 .isIgnored = false,
4927 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4928 .numberOfConsumers = 1,
4929 .scale = 0.0f,
4930 .type = TestOperandType::FLOAT32,
4931 .zeroPoint = 0
4932 }, { // axis
4933 .channelQuant = {},
4934 .data = TestBuffer::createFromVector<int32_t>({0}),
4935 .dimensions = {},
4936 .isIgnored = false,
4937 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4938 .numberOfConsumers = 1,
4939 .scale = 0.0f,
4940 .type = TestOperandType::INT32,
4941 .zeroPoint = 0
4942 }, { // op2
4943 .channelQuant = {},
4944 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
4945 .dimensions = {5, 2, 2},
4946 .isIgnored = false,
4947 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4948 .numberOfConsumers = 0,
4949 .scale = 0.0f,
4950 .type = TestOperandType::TENSOR_FLOAT32,
4951 .zeroPoint = 0
4952 }},
4953 .operations = {{
4954 .inputs = {0, 1, 2},
4955 .outputs = {3},
4956 .type = TestOperationType::SOFTMAX
4957 }},
4958 .outputIndexes = {3}
4959 },
4960 .minSupportedVersion = TestHalVersion::V1_2,
4961 .referenced = {}
4962 };
4963 return model;
4964 }
4965
4966 const auto dummy_test_model_axis_dim3_axis0 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0", get_test_model_axis_dim3_axis0());
4967
4968 } // namespace generated_tests::softmax_v1_2
4969
4970 namespace generated_tests::softmax_v1_2 {
4971
get_test_model_axis_dim3_axis0_all_inputs_as_internal()4972 const TestModel& get_test_model_axis_dim3_axis0_all_inputs_as_internal() {
4973 static TestModel model = {
4974 .expectFailure = false,
4975 .expectedMultinomialDistributionTolerance = 0,
4976 .isRelaxed = false,
4977 .main = { // axis
4978 .inputIndexes = {4},
4979 .operands = {{ // op1
4980 .channelQuant = {},
4981 .data = TestBuffer::createFromVector<float>({}),
4982 .dimensions = {5, 2, 2},
4983 .isIgnored = false,
4984 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4985 .numberOfConsumers = 1,
4986 .scale = 0.0f,
4987 .type = TestOperandType::TENSOR_FLOAT32,
4988 .zeroPoint = 0
4989 }, { // param2
4990 .channelQuant = {},
4991 .data = TestBuffer::createFromVector<float>({1.0f}),
4992 .dimensions = {},
4993 .isIgnored = false,
4994 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4995 .numberOfConsumers = 1,
4996 .scale = 0.0f,
4997 .type = TestOperandType::FLOAT32,
4998 .zeroPoint = 0
4999 }, { // axis
5000 .channelQuant = {},
5001 .data = TestBuffer::createFromVector<int32_t>({0}),
5002 .dimensions = {},
5003 .isIgnored = false,
5004 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5005 .numberOfConsumers = 1,
5006 .scale = 0.0f,
5007 .type = TestOperandType::INT32,
5008 .zeroPoint = 0
5009 }, { // op2
5010 .channelQuant = {},
5011 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5012 .dimensions = {5, 2, 2},
5013 .isIgnored = false,
5014 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5015 .numberOfConsumers = 0,
5016 .scale = 0.0f,
5017 .type = TestOperandType::TENSOR_FLOAT32,
5018 .zeroPoint = 0
5019 }, { // op1_new
5020 .channelQuant = {},
5021 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
5022 .dimensions = {5, 2, 2},
5023 .isIgnored = false,
5024 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5025 .numberOfConsumers = 1,
5026 .scale = 0.0f,
5027 .type = TestOperandType::TENSOR_FLOAT32,
5028 .zeroPoint = 0
5029 }, { // placeholder32
5030 .channelQuant = {},
5031 .data = TestBuffer::createFromVector<float>({0.0f}),
5032 .dimensions = {1},
5033 .isIgnored = false,
5034 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5035 .numberOfConsumers = 1,
5036 .scale = 0.0f,
5037 .type = TestOperandType::TENSOR_FLOAT32,
5038 .zeroPoint = 0
5039 }, { // param50
5040 .channelQuant = {},
5041 .data = TestBuffer::createFromVector<int32_t>({0}),
5042 .dimensions = {},
5043 .isIgnored = false,
5044 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5045 .numberOfConsumers = 1,
5046 .scale = 0.0f,
5047 .type = TestOperandType::INT32,
5048 .zeroPoint = 0
5049 }},
5050 .operations = {{
5051 .inputs = {4, 5, 6},
5052 .outputs = {0},
5053 .type = TestOperationType::ADD
5054 }, {
5055 .inputs = {0, 1, 2},
5056 .outputs = {3},
5057 .type = TestOperationType::SOFTMAX
5058 }},
5059 .outputIndexes = {3}
5060 },
5061 .minSupportedVersion = TestHalVersion::V1_2,
5062 .referenced = {}
5063 };
5064 return model;
5065 }
5066
5067 const auto dummy_test_model_axis_dim3_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0_all_inputs_as_internal", get_test_model_axis_dim3_axis0_all_inputs_as_internal());
5068
5069 } // namespace generated_tests::softmax_v1_2
5070
5071 namespace generated_tests::softmax_v1_2 {
5072
get_test_model_axis_dim3_axis0_neg()5073 const TestModel& get_test_model_axis_dim3_axis0_neg() {
5074 static TestModel model = {
5075 .expectFailure = false,
5076 .expectedMultinomialDistributionTolerance = 0,
5077 .isRelaxed = false,
5078 .main = { // axis
5079 .inputIndexes = {0},
5080 .operands = {{ // op1
5081 .channelQuant = {},
5082 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
5083 .dimensions = {5, 2, 2},
5084 .isIgnored = false,
5085 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5086 .numberOfConsumers = 1,
5087 .scale = 0.0f,
5088 .type = TestOperandType::TENSOR_FLOAT32,
5089 .zeroPoint = 0
5090 }, { // param2
5091 .channelQuant = {},
5092 .data = TestBuffer::createFromVector<float>({1.0f}),
5093 .dimensions = {},
5094 .isIgnored = false,
5095 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5096 .numberOfConsumers = 1,
5097 .scale = 0.0f,
5098 .type = TestOperandType::FLOAT32,
5099 .zeroPoint = 0
5100 }, { // axis
5101 .channelQuant = {},
5102 .data = TestBuffer::createFromVector<int32_t>({-3}),
5103 .dimensions = {},
5104 .isIgnored = false,
5105 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5106 .numberOfConsumers = 1,
5107 .scale = 0.0f,
5108 .type = TestOperandType::INT32,
5109 .zeroPoint = 0
5110 }, { // op2
5111 .channelQuant = {},
5112 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5113 .dimensions = {5, 2, 2},
5114 .isIgnored = false,
5115 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5116 .numberOfConsumers = 0,
5117 .scale = 0.0f,
5118 .type = TestOperandType::TENSOR_FLOAT32,
5119 .zeroPoint = 0
5120 }},
5121 .operations = {{
5122 .inputs = {0, 1, 2},
5123 .outputs = {3},
5124 .type = TestOperationType::SOFTMAX
5125 }},
5126 .outputIndexes = {3}
5127 },
5128 .minSupportedVersion = TestHalVersion::V1_2,
5129 .referenced = {}
5130 };
5131 return model;
5132 }
5133
5134 const auto dummy_test_model_axis_dim3_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0_neg", get_test_model_axis_dim3_axis0_neg());
5135
5136 } // namespace generated_tests::softmax_v1_2
5137
5138 namespace generated_tests::softmax_v1_2 {
5139
get_test_model_axis_dim3_axis0_neg_all_inputs_as_internal()5140 const TestModel& get_test_model_axis_dim3_axis0_neg_all_inputs_as_internal() {
5141 static TestModel model = {
5142 .expectFailure = false,
5143 .expectedMultinomialDistributionTolerance = 0,
5144 .isRelaxed = false,
5145 .main = { // axis
5146 .inputIndexes = {4},
5147 .operands = {{ // op1
5148 .channelQuant = {},
5149 .data = TestBuffer::createFromVector<float>({}),
5150 .dimensions = {5, 2, 2},
5151 .isIgnored = false,
5152 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5153 .numberOfConsumers = 1,
5154 .scale = 0.0f,
5155 .type = TestOperandType::TENSOR_FLOAT32,
5156 .zeroPoint = 0
5157 }, { // param2
5158 .channelQuant = {},
5159 .data = TestBuffer::createFromVector<float>({1.0f}),
5160 .dimensions = {},
5161 .isIgnored = false,
5162 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5163 .numberOfConsumers = 1,
5164 .scale = 0.0f,
5165 .type = TestOperandType::FLOAT32,
5166 .zeroPoint = 0
5167 }, { // axis
5168 .channelQuant = {},
5169 .data = TestBuffer::createFromVector<int32_t>({-3}),
5170 .dimensions = {},
5171 .isIgnored = false,
5172 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5173 .numberOfConsumers = 1,
5174 .scale = 0.0f,
5175 .type = TestOperandType::INT32,
5176 .zeroPoint = 0
5177 }, { // op2
5178 .channelQuant = {},
5179 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5180 .dimensions = {5, 2, 2},
5181 .isIgnored = false,
5182 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5183 .numberOfConsumers = 0,
5184 .scale = 0.0f,
5185 .type = TestOperandType::TENSOR_FLOAT32,
5186 .zeroPoint = 0
5187 }, { // op1_new
5188 .channelQuant = {},
5189 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
5190 .dimensions = {5, 2, 2},
5191 .isIgnored = false,
5192 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5193 .numberOfConsumers = 1,
5194 .scale = 0.0f,
5195 .type = TestOperandType::TENSOR_FLOAT32,
5196 .zeroPoint = 0
5197 }, { // placeholder33
5198 .channelQuant = {},
5199 .data = TestBuffer::createFromVector<float>({0.0f}),
5200 .dimensions = {1},
5201 .isIgnored = false,
5202 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5203 .numberOfConsumers = 1,
5204 .scale = 0.0f,
5205 .type = TestOperandType::TENSOR_FLOAT32,
5206 .zeroPoint = 0
5207 }, { // param51
5208 .channelQuant = {},
5209 .data = TestBuffer::createFromVector<int32_t>({0}),
5210 .dimensions = {},
5211 .isIgnored = false,
5212 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5213 .numberOfConsumers = 1,
5214 .scale = 0.0f,
5215 .type = TestOperandType::INT32,
5216 .zeroPoint = 0
5217 }},
5218 .operations = {{
5219 .inputs = {4, 5, 6},
5220 .outputs = {0},
5221 .type = TestOperationType::ADD
5222 }, {
5223 .inputs = {0, 1, 2},
5224 .outputs = {3},
5225 .type = TestOperationType::SOFTMAX
5226 }},
5227 .outputIndexes = {3}
5228 },
5229 .minSupportedVersion = TestHalVersion::V1_2,
5230 .referenced = {}
5231 };
5232 return model;
5233 }
5234
5235 const auto dummy_test_model_axis_dim3_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0_neg_all_inputs_as_internal", get_test_model_axis_dim3_axis0_neg_all_inputs_as_internal());
5236
5237 } // namespace generated_tests::softmax_v1_2
5238
5239 namespace generated_tests::softmax_v1_2 {
5240
get_test_model_axis_dim3_axis1()5241 const TestModel& get_test_model_axis_dim3_axis1() {
5242 static TestModel model = {
5243 .expectFailure = false,
5244 .expectedMultinomialDistributionTolerance = 0,
5245 .isRelaxed = false,
5246 .main = { // axis
5247 .inputIndexes = {0},
5248 .operands = {{ // op1
5249 .channelQuant = {},
5250 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
5251 .dimensions = {2, 5, 2},
5252 .isIgnored = false,
5253 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5254 .numberOfConsumers = 1,
5255 .scale = 0.0f,
5256 .type = TestOperandType::TENSOR_FLOAT32,
5257 .zeroPoint = 0
5258 }, { // param2
5259 .channelQuant = {},
5260 .data = TestBuffer::createFromVector<float>({1.0f}),
5261 .dimensions = {},
5262 .isIgnored = false,
5263 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5264 .numberOfConsumers = 1,
5265 .scale = 0.0f,
5266 .type = TestOperandType::FLOAT32,
5267 .zeroPoint = 0
5268 }, { // axis
5269 .channelQuant = {},
5270 .data = TestBuffer::createFromVector<int32_t>({1}),
5271 .dimensions = {},
5272 .isIgnored = false,
5273 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5274 .numberOfConsumers = 1,
5275 .scale = 0.0f,
5276 .type = TestOperandType::INT32,
5277 .zeroPoint = 0
5278 }, { // op2
5279 .channelQuant = {},
5280 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5281 .dimensions = {2, 5, 2},
5282 .isIgnored = false,
5283 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5284 .numberOfConsumers = 0,
5285 .scale = 0.0f,
5286 .type = TestOperandType::TENSOR_FLOAT32,
5287 .zeroPoint = 0
5288 }},
5289 .operations = {{
5290 .inputs = {0, 1, 2},
5291 .outputs = {3},
5292 .type = TestOperationType::SOFTMAX
5293 }},
5294 .outputIndexes = {3}
5295 },
5296 .minSupportedVersion = TestHalVersion::V1_2,
5297 .referenced = {}
5298 };
5299 return model;
5300 }
5301
5302 const auto dummy_test_model_axis_dim3_axis1 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1", get_test_model_axis_dim3_axis1());
5303
5304 } // namespace generated_tests::softmax_v1_2
5305
5306 namespace generated_tests::softmax_v1_2 {
5307
get_test_model_axis_dim3_axis1_all_inputs_as_internal()5308 const TestModel& get_test_model_axis_dim3_axis1_all_inputs_as_internal() {
5309 static TestModel model = {
5310 .expectFailure = false,
5311 .expectedMultinomialDistributionTolerance = 0,
5312 .isRelaxed = false,
5313 .main = { // axis
5314 .inputIndexes = {4},
5315 .operands = {{ // op1
5316 .channelQuant = {},
5317 .data = TestBuffer::createFromVector<float>({}),
5318 .dimensions = {2, 5, 2},
5319 .isIgnored = false,
5320 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5321 .numberOfConsumers = 1,
5322 .scale = 0.0f,
5323 .type = TestOperandType::TENSOR_FLOAT32,
5324 .zeroPoint = 0
5325 }, { // param2
5326 .channelQuant = {},
5327 .data = TestBuffer::createFromVector<float>({1.0f}),
5328 .dimensions = {},
5329 .isIgnored = false,
5330 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5331 .numberOfConsumers = 1,
5332 .scale = 0.0f,
5333 .type = TestOperandType::FLOAT32,
5334 .zeroPoint = 0
5335 }, { // axis
5336 .channelQuant = {},
5337 .data = TestBuffer::createFromVector<int32_t>({1}),
5338 .dimensions = {},
5339 .isIgnored = false,
5340 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5341 .numberOfConsumers = 1,
5342 .scale = 0.0f,
5343 .type = TestOperandType::INT32,
5344 .zeroPoint = 0
5345 }, { // op2
5346 .channelQuant = {},
5347 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5348 .dimensions = {2, 5, 2},
5349 .isIgnored = false,
5350 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5351 .numberOfConsumers = 0,
5352 .scale = 0.0f,
5353 .type = TestOperandType::TENSOR_FLOAT32,
5354 .zeroPoint = 0
5355 }, { // op1_new
5356 .channelQuant = {},
5357 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
5358 .dimensions = {2, 5, 2},
5359 .isIgnored = false,
5360 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5361 .numberOfConsumers = 1,
5362 .scale = 0.0f,
5363 .type = TestOperandType::TENSOR_FLOAT32,
5364 .zeroPoint = 0
5365 }, { // placeholder34
5366 .channelQuant = {},
5367 .data = TestBuffer::createFromVector<float>({0.0f}),
5368 .dimensions = {1},
5369 .isIgnored = false,
5370 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5371 .numberOfConsumers = 1,
5372 .scale = 0.0f,
5373 .type = TestOperandType::TENSOR_FLOAT32,
5374 .zeroPoint = 0
5375 }, { // param52
5376 .channelQuant = {},
5377 .data = TestBuffer::createFromVector<int32_t>({0}),
5378 .dimensions = {},
5379 .isIgnored = false,
5380 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5381 .numberOfConsumers = 1,
5382 .scale = 0.0f,
5383 .type = TestOperandType::INT32,
5384 .zeroPoint = 0
5385 }},
5386 .operations = {{
5387 .inputs = {4, 5, 6},
5388 .outputs = {0},
5389 .type = TestOperationType::ADD
5390 }, {
5391 .inputs = {0, 1, 2},
5392 .outputs = {3},
5393 .type = TestOperationType::SOFTMAX
5394 }},
5395 .outputIndexes = {3}
5396 },
5397 .minSupportedVersion = TestHalVersion::V1_2,
5398 .referenced = {}
5399 };
5400 return model;
5401 }
5402
5403 const auto dummy_test_model_axis_dim3_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1_all_inputs_as_internal", get_test_model_axis_dim3_axis1_all_inputs_as_internal());
5404
5405 } // namespace generated_tests::softmax_v1_2
5406
5407 namespace generated_tests::softmax_v1_2 {
5408
get_test_model_axis_dim3_axis1_neg()5409 const TestModel& get_test_model_axis_dim3_axis1_neg() {
5410 static TestModel model = {
5411 .expectFailure = false,
5412 .expectedMultinomialDistributionTolerance = 0,
5413 .isRelaxed = false,
5414 .main = { // axis
5415 .inputIndexes = {0},
5416 .operands = {{ // op1
5417 .channelQuant = {},
5418 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
5419 .dimensions = {2, 5, 2},
5420 .isIgnored = false,
5421 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5422 .numberOfConsumers = 1,
5423 .scale = 0.0f,
5424 .type = TestOperandType::TENSOR_FLOAT32,
5425 .zeroPoint = 0
5426 }, { // param2
5427 .channelQuant = {},
5428 .data = TestBuffer::createFromVector<float>({1.0f}),
5429 .dimensions = {},
5430 .isIgnored = false,
5431 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5432 .numberOfConsumers = 1,
5433 .scale = 0.0f,
5434 .type = TestOperandType::FLOAT32,
5435 .zeroPoint = 0
5436 }, { // axis
5437 .channelQuant = {},
5438 .data = TestBuffer::createFromVector<int32_t>({-2}),
5439 .dimensions = {},
5440 .isIgnored = false,
5441 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5442 .numberOfConsumers = 1,
5443 .scale = 0.0f,
5444 .type = TestOperandType::INT32,
5445 .zeroPoint = 0
5446 }, { // op2
5447 .channelQuant = {},
5448 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5449 .dimensions = {2, 5, 2},
5450 .isIgnored = false,
5451 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5452 .numberOfConsumers = 0,
5453 .scale = 0.0f,
5454 .type = TestOperandType::TENSOR_FLOAT32,
5455 .zeroPoint = 0
5456 }},
5457 .operations = {{
5458 .inputs = {0, 1, 2},
5459 .outputs = {3},
5460 .type = TestOperationType::SOFTMAX
5461 }},
5462 .outputIndexes = {3}
5463 },
5464 .minSupportedVersion = TestHalVersion::V1_2,
5465 .referenced = {}
5466 };
5467 return model;
5468 }
5469
5470 const auto dummy_test_model_axis_dim3_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1_neg", get_test_model_axis_dim3_axis1_neg());
5471
5472 } // namespace generated_tests::softmax_v1_2
5473
5474 namespace generated_tests::softmax_v1_2 {
5475
get_test_model_axis_dim3_axis1_neg_all_inputs_as_internal()5476 const TestModel& get_test_model_axis_dim3_axis1_neg_all_inputs_as_internal() {
5477 static TestModel model = {
5478 .expectFailure = false,
5479 .expectedMultinomialDistributionTolerance = 0,
5480 .isRelaxed = false,
5481 .main = { // axis
5482 .inputIndexes = {4},
5483 .operands = {{ // op1
5484 .channelQuant = {},
5485 .data = TestBuffer::createFromVector<float>({}),
5486 .dimensions = {2, 5, 2},
5487 .isIgnored = false,
5488 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5489 .numberOfConsumers = 1,
5490 .scale = 0.0f,
5491 .type = TestOperandType::TENSOR_FLOAT32,
5492 .zeroPoint = 0
5493 }, { // param2
5494 .channelQuant = {},
5495 .data = TestBuffer::createFromVector<float>({1.0f}),
5496 .dimensions = {},
5497 .isIgnored = false,
5498 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5499 .numberOfConsumers = 1,
5500 .scale = 0.0f,
5501 .type = TestOperandType::FLOAT32,
5502 .zeroPoint = 0
5503 }, { // axis
5504 .channelQuant = {},
5505 .data = TestBuffer::createFromVector<int32_t>({-2}),
5506 .dimensions = {},
5507 .isIgnored = false,
5508 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5509 .numberOfConsumers = 1,
5510 .scale = 0.0f,
5511 .type = TestOperandType::INT32,
5512 .zeroPoint = 0
5513 }, { // op2
5514 .channelQuant = {},
5515 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5516 .dimensions = {2, 5, 2},
5517 .isIgnored = false,
5518 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5519 .numberOfConsumers = 0,
5520 .scale = 0.0f,
5521 .type = TestOperandType::TENSOR_FLOAT32,
5522 .zeroPoint = 0
5523 }, { // op1_new
5524 .channelQuant = {},
5525 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
5526 .dimensions = {2, 5, 2},
5527 .isIgnored = false,
5528 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5529 .numberOfConsumers = 1,
5530 .scale = 0.0f,
5531 .type = TestOperandType::TENSOR_FLOAT32,
5532 .zeroPoint = 0
5533 }, { // placeholder35
5534 .channelQuant = {},
5535 .data = TestBuffer::createFromVector<float>({0.0f}),
5536 .dimensions = {1},
5537 .isIgnored = false,
5538 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5539 .numberOfConsumers = 1,
5540 .scale = 0.0f,
5541 .type = TestOperandType::TENSOR_FLOAT32,
5542 .zeroPoint = 0
5543 }, { // param53
5544 .channelQuant = {},
5545 .data = TestBuffer::createFromVector<int32_t>({0}),
5546 .dimensions = {},
5547 .isIgnored = false,
5548 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5549 .numberOfConsumers = 1,
5550 .scale = 0.0f,
5551 .type = TestOperandType::INT32,
5552 .zeroPoint = 0
5553 }},
5554 .operations = {{
5555 .inputs = {4, 5, 6},
5556 .outputs = {0},
5557 .type = TestOperationType::ADD
5558 }, {
5559 .inputs = {0, 1, 2},
5560 .outputs = {3},
5561 .type = TestOperationType::SOFTMAX
5562 }},
5563 .outputIndexes = {3}
5564 },
5565 .minSupportedVersion = TestHalVersion::V1_2,
5566 .referenced = {}
5567 };
5568 return model;
5569 }
5570
5571 const auto dummy_test_model_axis_dim3_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1_neg_all_inputs_as_internal", get_test_model_axis_dim3_axis1_neg_all_inputs_as_internal());
5572
5573 } // namespace generated_tests::softmax_v1_2
5574
5575 namespace generated_tests::softmax_v1_2 {
5576
get_test_model_axis_dim3_axis2()5577 const TestModel& get_test_model_axis_dim3_axis2() {
5578 static TestModel model = {
5579 .expectFailure = false,
5580 .expectedMultinomialDistributionTolerance = 0,
5581 .isRelaxed = false,
5582 .main = { // axis
5583 .inputIndexes = {0},
5584 .operands = {{ // op1
5585 .channelQuant = {},
5586 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
5587 .dimensions = {2, 2, 5},
5588 .isIgnored = false,
5589 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5590 .numberOfConsumers = 1,
5591 .scale = 0.0f,
5592 .type = TestOperandType::TENSOR_FLOAT32,
5593 .zeroPoint = 0
5594 }, { // param2
5595 .channelQuant = {},
5596 .data = TestBuffer::createFromVector<float>({1.0f}),
5597 .dimensions = {},
5598 .isIgnored = false,
5599 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5600 .numberOfConsumers = 1,
5601 .scale = 0.0f,
5602 .type = TestOperandType::FLOAT32,
5603 .zeroPoint = 0
5604 }, { // axis
5605 .channelQuant = {},
5606 .data = TestBuffer::createFromVector<int32_t>({2}),
5607 .dimensions = {},
5608 .isIgnored = false,
5609 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5610 .numberOfConsumers = 1,
5611 .scale = 0.0f,
5612 .type = TestOperandType::INT32,
5613 .zeroPoint = 0
5614 }, { // op2
5615 .channelQuant = {},
5616 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
5617 .dimensions = {2, 2, 5},
5618 .isIgnored = false,
5619 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5620 .numberOfConsumers = 0,
5621 .scale = 0.0f,
5622 .type = TestOperandType::TENSOR_FLOAT32,
5623 .zeroPoint = 0
5624 }},
5625 .operations = {{
5626 .inputs = {0, 1, 2},
5627 .outputs = {3},
5628 .type = TestOperationType::SOFTMAX
5629 }},
5630 .outputIndexes = {3}
5631 },
5632 .minSupportedVersion = TestHalVersion::V1_2,
5633 .referenced = {}
5634 };
5635 return model;
5636 }
5637
5638 const auto dummy_test_model_axis_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2", get_test_model_axis_dim3_axis2());
5639
5640 } // namespace generated_tests::softmax_v1_2
5641
5642 namespace generated_tests::softmax_v1_2 {
5643
get_test_model_axis_dim3_axis2_all_inputs_as_internal()5644 const TestModel& get_test_model_axis_dim3_axis2_all_inputs_as_internal() {
5645 static TestModel model = {
5646 .expectFailure = false,
5647 .expectedMultinomialDistributionTolerance = 0,
5648 .isRelaxed = false,
5649 .main = { // axis
5650 .inputIndexes = {4},
5651 .operands = {{ // op1
5652 .channelQuant = {},
5653 .data = TestBuffer::createFromVector<float>({}),
5654 .dimensions = {2, 2, 5},
5655 .isIgnored = false,
5656 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5657 .numberOfConsumers = 1,
5658 .scale = 0.0f,
5659 .type = TestOperandType::TENSOR_FLOAT32,
5660 .zeroPoint = 0
5661 }, { // param2
5662 .channelQuant = {},
5663 .data = TestBuffer::createFromVector<float>({1.0f}),
5664 .dimensions = {},
5665 .isIgnored = false,
5666 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5667 .numberOfConsumers = 1,
5668 .scale = 0.0f,
5669 .type = TestOperandType::FLOAT32,
5670 .zeroPoint = 0
5671 }, { // axis
5672 .channelQuant = {},
5673 .data = TestBuffer::createFromVector<int32_t>({2}),
5674 .dimensions = {},
5675 .isIgnored = false,
5676 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5677 .numberOfConsumers = 1,
5678 .scale = 0.0f,
5679 .type = TestOperandType::INT32,
5680 .zeroPoint = 0
5681 }, { // op2
5682 .channelQuant = {},
5683 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
5684 .dimensions = {2, 2, 5},
5685 .isIgnored = false,
5686 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5687 .numberOfConsumers = 0,
5688 .scale = 0.0f,
5689 .type = TestOperandType::TENSOR_FLOAT32,
5690 .zeroPoint = 0
5691 }, { // op1_new
5692 .channelQuant = {},
5693 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
5694 .dimensions = {2, 2, 5},
5695 .isIgnored = false,
5696 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5697 .numberOfConsumers = 1,
5698 .scale = 0.0f,
5699 .type = TestOperandType::TENSOR_FLOAT32,
5700 .zeroPoint = 0
5701 }, { // placeholder36
5702 .channelQuant = {},
5703 .data = TestBuffer::createFromVector<float>({0.0f}),
5704 .dimensions = {1},
5705 .isIgnored = false,
5706 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5707 .numberOfConsumers = 1,
5708 .scale = 0.0f,
5709 .type = TestOperandType::TENSOR_FLOAT32,
5710 .zeroPoint = 0
5711 }, { // param54
5712 .channelQuant = {},
5713 .data = TestBuffer::createFromVector<int32_t>({0}),
5714 .dimensions = {},
5715 .isIgnored = false,
5716 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5717 .numberOfConsumers = 1,
5718 .scale = 0.0f,
5719 .type = TestOperandType::INT32,
5720 .zeroPoint = 0
5721 }},
5722 .operations = {{
5723 .inputs = {4, 5, 6},
5724 .outputs = {0},
5725 .type = TestOperationType::ADD
5726 }, {
5727 .inputs = {0, 1, 2},
5728 .outputs = {3},
5729 .type = TestOperationType::SOFTMAX
5730 }},
5731 .outputIndexes = {3}
5732 },
5733 .minSupportedVersion = TestHalVersion::V1_2,
5734 .referenced = {}
5735 };
5736 return model;
5737 }
5738
5739 const auto dummy_test_model_axis_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2_all_inputs_as_internal", get_test_model_axis_dim3_axis2_all_inputs_as_internal());
5740
5741 } // namespace generated_tests::softmax_v1_2
5742
5743 namespace generated_tests::softmax_v1_2 {
5744
get_test_model_axis_dim3_axis2_neg()5745 const TestModel& get_test_model_axis_dim3_axis2_neg() {
5746 static TestModel model = {
5747 .expectFailure = false,
5748 .expectedMultinomialDistributionTolerance = 0,
5749 .isRelaxed = false,
5750 .main = { // axis
5751 .inputIndexes = {0},
5752 .operands = {{ // op1
5753 .channelQuant = {},
5754 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
5755 .dimensions = {2, 2, 5},
5756 .isIgnored = false,
5757 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5758 .numberOfConsumers = 1,
5759 .scale = 0.0f,
5760 .type = TestOperandType::TENSOR_FLOAT32,
5761 .zeroPoint = 0
5762 }, { // param2
5763 .channelQuant = {},
5764 .data = TestBuffer::createFromVector<float>({1.0f}),
5765 .dimensions = {},
5766 .isIgnored = false,
5767 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5768 .numberOfConsumers = 1,
5769 .scale = 0.0f,
5770 .type = TestOperandType::FLOAT32,
5771 .zeroPoint = 0
5772 }, { // axis
5773 .channelQuant = {},
5774 .data = TestBuffer::createFromVector<int32_t>({-1}),
5775 .dimensions = {},
5776 .isIgnored = false,
5777 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5778 .numberOfConsumers = 1,
5779 .scale = 0.0f,
5780 .type = TestOperandType::INT32,
5781 .zeroPoint = 0
5782 }, { // op2
5783 .channelQuant = {},
5784 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
5785 .dimensions = {2, 2, 5},
5786 .isIgnored = false,
5787 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5788 .numberOfConsumers = 0,
5789 .scale = 0.0f,
5790 .type = TestOperandType::TENSOR_FLOAT32,
5791 .zeroPoint = 0
5792 }},
5793 .operations = {{
5794 .inputs = {0, 1, 2},
5795 .outputs = {3},
5796 .type = TestOperationType::SOFTMAX
5797 }},
5798 .outputIndexes = {3}
5799 },
5800 .minSupportedVersion = TestHalVersion::V1_2,
5801 .referenced = {}
5802 };
5803 return model;
5804 }
5805
5806 const auto dummy_test_model_axis_dim3_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2_neg", get_test_model_axis_dim3_axis2_neg());
5807
5808 } // namespace generated_tests::softmax_v1_2
5809
5810 namespace generated_tests::softmax_v1_2 {
5811
get_test_model_axis_dim3_axis2_neg_all_inputs_as_internal()5812 const TestModel& get_test_model_axis_dim3_axis2_neg_all_inputs_as_internal() {
5813 static TestModel model = {
5814 .expectFailure = false,
5815 .expectedMultinomialDistributionTolerance = 0,
5816 .isRelaxed = false,
5817 .main = { // axis
5818 .inputIndexes = {4},
5819 .operands = {{ // op1
5820 .channelQuant = {},
5821 .data = TestBuffer::createFromVector<float>({}),
5822 .dimensions = {2, 2, 5},
5823 .isIgnored = false,
5824 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5825 .numberOfConsumers = 1,
5826 .scale = 0.0f,
5827 .type = TestOperandType::TENSOR_FLOAT32,
5828 .zeroPoint = 0
5829 }, { // param2
5830 .channelQuant = {},
5831 .data = TestBuffer::createFromVector<float>({1.0f}),
5832 .dimensions = {},
5833 .isIgnored = false,
5834 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5835 .numberOfConsumers = 1,
5836 .scale = 0.0f,
5837 .type = TestOperandType::FLOAT32,
5838 .zeroPoint = 0
5839 }, { // axis
5840 .channelQuant = {},
5841 .data = TestBuffer::createFromVector<int32_t>({-1}),
5842 .dimensions = {},
5843 .isIgnored = false,
5844 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5845 .numberOfConsumers = 1,
5846 .scale = 0.0f,
5847 .type = TestOperandType::INT32,
5848 .zeroPoint = 0
5849 }, { // op2
5850 .channelQuant = {},
5851 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
5852 .dimensions = {2, 2, 5},
5853 .isIgnored = false,
5854 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5855 .numberOfConsumers = 0,
5856 .scale = 0.0f,
5857 .type = TestOperandType::TENSOR_FLOAT32,
5858 .zeroPoint = 0
5859 }, { // op1_new
5860 .channelQuant = {},
5861 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
5862 .dimensions = {2, 2, 5},
5863 .isIgnored = false,
5864 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5865 .numberOfConsumers = 1,
5866 .scale = 0.0f,
5867 .type = TestOperandType::TENSOR_FLOAT32,
5868 .zeroPoint = 0
5869 }, { // placeholder37
5870 .channelQuant = {},
5871 .data = TestBuffer::createFromVector<float>({0.0f}),
5872 .dimensions = {1},
5873 .isIgnored = false,
5874 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5875 .numberOfConsumers = 1,
5876 .scale = 0.0f,
5877 .type = TestOperandType::TENSOR_FLOAT32,
5878 .zeroPoint = 0
5879 }, { // param55
5880 .channelQuant = {},
5881 .data = TestBuffer::createFromVector<int32_t>({0}),
5882 .dimensions = {},
5883 .isIgnored = false,
5884 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5885 .numberOfConsumers = 1,
5886 .scale = 0.0f,
5887 .type = TestOperandType::INT32,
5888 .zeroPoint = 0
5889 }},
5890 .operations = {{
5891 .inputs = {4, 5, 6},
5892 .outputs = {0},
5893 .type = TestOperationType::ADD
5894 }, {
5895 .inputs = {0, 1, 2},
5896 .outputs = {3},
5897 .type = TestOperationType::SOFTMAX
5898 }},
5899 .outputIndexes = {3}
5900 },
5901 .minSupportedVersion = TestHalVersion::V1_2,
5902 .referenced = {}
5903 };
5904 return model;
5905 }
5906
5907 const auto dummy_test_model_axis_dim3_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2_neg_all_inputs_as_internal", get_test_model_axis_dim3_axis2_neg_all_inputs_as_internal());
5908
5909 } // namespace generated_tests::softmax_v1_2
5910
5911 namespace generated_tests::softmax_v1_2 {
5912
get_test_model_axis_dim2_axis0()5913 const TestModel& get_test_model_axis_dim2_axis0() {
5914 static TestModel model = {
5915 .expectFailure = false,
5916 .expectedMultinomialDistributionTolerance = 0,
5917 .isRelaxed = false,
5918 .main = { // axis
5919 .inputIndexes = {0},
5920 .operands = {{ // op1
5921 .channelQuant = {},
5922 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
5923 .dimensions = {5, 2},
5924 .isIgnored = false,
5925 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5926 .numberOfConsumers = 1,
5927 .scale = 0.0f,
5928 .type = TestOperandType::TENSOR_FLOAT32,
5929 .zeroPoint = 0
5930 }, { // param2
5931 .channelQuant = {},
5932 .data = TestBuffer::createFromVector<float>({1.0f}),
5933 .dimensions = {},
5934 .isIgnored = false,
5935 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5936 .numberOfConsumers = 1,
5937 .scale = 0.0f,
5938 .type = TestOperandType::FLOAT32,
5939 .zeroPoint = 0
5940 }, { // axis
5941 .channelQuant = {},
5942 .data = TestBuffer::createFromVector<int32_t>({0}),
5943 .dimensions = {},
5944 .isIgnored = false,
5945 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5946 .numberOfConsumers = 1,
5947 .scale = 0.0f,
5948 .type = TestOperandType::INT32,
5949 .zeroPoint = 0
5950 }, { // op2
5951 .channelQuant = {},
5952 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
5953 .dimensions = {5, 2},
5954 .isIgnored = false,
5955 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5956 .numberOfConsumers = 0,
5957 .scale = 0.0f,
5958 .type = TestOperandType::TENSOR_FLOAT32,
5959 .zeroPoint = 0
5960 }},
5961 .operations = {{
5962 .inputs = {0, 1, 2},
5963 .outputs = {3},
5964 .type = TestOperationType::SOFTMAX
5965 }},
5966 .outputIndexes = {3}
5967 },
5968 .minSupportedVersion = TestHalVersion::V1_2,
5969 .referenced = {}
5970 };
5971 return model;
5972 }
5973
5974 const auto dummy_test_model_axis_dim2_axis0 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0", get_test_model_axis_dim2_axis0());
5975
5976 } // namespace generated_tests::softmax_v1_2
5977
5978 namespace generated_tests::softmax_v1_2 {
5979
get_test_model_axis_dim2_axis0_all_inputs_as_internal()5980 const TestModel& get_test_model_axis_dim2_axis0_all_inputs_as_internal() {
5981 static TestModel model = {
5982 .expectFailure = false,
5983 .expectedMultinomialDistributionTolerance = 0,
5984 .isRelaxed = false,
5985 .main = { // axis
5986 .inputIndexes = {4},
5987 .operands = {{ // op1
5988 .channelQuant = {},
5989 .data = TestBuffer::createFromVector<float>({}),
5990 .dimensions = {5, 2},
5991 .isIgnored = false,
5992 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5993 .numberOfConsumers = 1,
5994 .scale = 0.0f,
5995 .type = TestOperandType::TENSOR_FLOAT32,
5996 .zeroPoint = 0
5997 }, { // param2
5998 .channelQuant = {},
5999 .data = TestBuffer::createFromVector<float>({1.0f}),
6000 .dimensions = {},
6001 .isIgnored = false,
6002 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6003 .numberOfConsumers = 1,
6004 .scale = 0.0f,
6005 .type = TestOperandType::FLOAT32,
6006 .zeroPoint = 0
6007 }, { // axis
6008 .channelQuant = {},
6009 .data = TestBuffer::createFromVector<int32_t>({0}),
6010 .dimensions = {},
6011 .isIgnored = false,
6012 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6013 .numberOfConsumers = 1,
6014 .scale = 0.0f,
6015 .type = TestOperandType::INT32,
6016 .zeroPoint = 0
6017 }, { // op2
6018 .channelQuant = {},
6019 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
6020 .dimensions = {5, 2},
6021 .isIgnored = false,
6022 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6023 .numberOfConsumers = 0,
6024 .scale = 0.0f,
6025 .type = TestOperandType::TENSOR_FLOAT32,
6026 .zeroPoint = 0
6027 }, { // op1_new
6028 .channelQuant = {},
6029 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
6030 .dimensions = {5, 2},
6031 .isIgnored = false,
6032 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6033 .numberOfConsumers = 1,
6034 .scale = 0.0f,
6035 .type = TestOperandType::TENSOR_FLOAT32,
6036 .zeroPoint = 0
6037 }, { // placeholder38
6038 .channelQuant = {},
6039 .data = TestBuffer::createFromVector<float>({0.0f}),
6040 .dimensions = {1},
6041 .isIgnored = false,
6042 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6043 .numberOfConsumers = 1,
6044 .scale = 0.0f,
6045 .type = TestOperandType::TENSOR_FLOAT32,
6046 .zeroPoint = 0
6047 }, { // param56
6048 .channelQuant = {},
6049 .data = TestBuffer::createFromVector<int32_t>({0}),
6050 .dimensions = {},
6051 .isIgnored = false,
6052 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6053 .numberOfConsumers = 1,
6054 .scale = 0.0f,
6055 .type = TestOperandType::INT32,
6056 .zeroPoint = 0
6057 }},
6058 .operations = {{
6059 .inputs = {4, 5, 6},
6060 .outputs = {0},
6061 .type = TestOperationType::ADD
6062 }, {
6063 .inputs = {0, 1, 2},
6064 .outputs = {3},
6065 .type = TestOperationType::SOFTMAX
6066 }},
6067 .outputIndexes = {3}
6068 },
6069 .minSupportedVersion = TestHalVersion::V1_2,
6070 .referenced = {}
6071 };
6072 return model;
6073 }
6074
6075 const auto dummy_test_model_axis_dim2_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0_all_inputs_as_internal", get_test_model_axis_dim2_axis0_all_inputs_as_internal());
6076
6077 } // namespace generated_tests::softmax_v1_2
6078
6079 namespace generated_tests::softmax_v1_2 {
6080
get_test_model_axis_dim2_axis0_neg()6081 const TestModel& get_test_model_axis_dim2_axis0_neg() {
6082 static TestModel model = {
6083 .expectFailure = false,
6084 .expectedMultinomialDistributionTolerance = 0,
6085 .isRelaxed = false,
6086 .main = { // axis
6087 .inputIndexes = {0},
6088 .operands = {{ // op1
6089 .channelQuant = {},
6090 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
6091 .dimensions = {5, 2},
6092 .isIgnored = false,
6093 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6094 .numberOfConsumers = 1,
6095 .scale = 0.0f,
6096 .type = TestOperandType::TENSOR_FLOAT32,
6097 .zeroPoint = 0
6098 }, { // param2
6099 .channelQuant = {},
6100 .data = TestBuffer::createFromVector<float>({1.0f}),
6101 .dimensions = {},
6102 .isIgnored = false,
6103 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6104 .numberOfConsumers = 1,
6105 .scale = 0.0f,
6106 .type = TestOperandType::FLOAT32,
6107 .zeroPoint = 0
6108 }, { // axis
6109 .channelQuant = {},
6110 .data = TestBuffer::createFromVector<int32_t>({-2}),
6111 .dimensions = {},
6112 .isIgnored = false,
6113 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6114 .numberOfConsumers = 1,
6115 .scale = 0.0f,
6116 .type = TestOperandType::INT32,
6117 .zeroPoint = 0
6118 }, { // op2
6119 .channelQuant = {},
6120 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
6121 .dimensions = {5, 2},
6122 .isIgnored = false,
6123 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6124 .numberOfConsumers = 0,
6125 .scale = 0.0f,
6126 .type = TestOperandType::TENSOR_FLOAT32,
6127 .zeroPoint = 0
6128 }},
6129 .operations = {{
6130 .inputs = {0, 1, 2},
6131 .outputs = {3},
6132 .type = TestOperationType::SOFTMAX
6133 }},
6134 .outputIndexes = {3}
6135 },
6136 .minSupportedVersion = TestHalVersion::V1_2,
6137 .referenced = {}
6138 };
6139 return model;
6140 }
6141
6142 const auto dummy_test_model_axis_dim2_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0_neg", get_test_model_axis_dim2_axis0_neg());
6143
6144 } // namespace generated_tests::softmax_v1_2
6145
6146 namespace generated_tests::softmax_v1_2 {
6147
get_test_model_axis_dim2_axis0_neg_all_inputs_as_internal()6148 const TestModel& get_test_model_axis_dim2_axis0_neg_all_inputs_as_internal() {
6149 static TestModel model = {
6150 .expectFailure = false,
6151 .expectedMultinomialDistributionTolerance = 0,
6152 .isRelaxed = false,
6153 .main = { // axis
6154 .inputIndexes = {4},
6155 .operands = {{ // op1
6156 .channelQuant = {},
6157 .data = TestBuffer::createFromVector<float>({}),
6158 .dimensions = {5, 2},
6159 .isIgnored = false,
6160 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6161 .numberOfConsumers = 1,
6162 .scale = 0.0f,
6163 .type = TestOperandType::TENSOR_FLOAT32,
6164 .zeroPoint = 0
6165 }, { // param2
6166 .channelQuant = {},
6167 .data = TestBuffer::createFromVector<float>({1.0f}),
6168 .dimensions = {},
6169 .isIgnored = false,
6170 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6171 .numberOfConsumers = 1,
6172 .scale = 0.0f,
6173 .type = TestOperandType::FLOAT32,
6174 .zeroPoint = 0
6175 }, { // axis
6176 .channelQuant = {},
6177 .data = TestBuffer::createFromVector<int32_t>({-2}),
6178 .dimensions = {},
6179 .isIgnored = false,
6180 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6181 .numberOfConsumers = 1,
6182 .scale = 0.0f,
6183 .type = TestOperandType::INT32,
6184 .zeroPoint = 0
6185 }, { // op2
6186 .channelQuant = {},
6187 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
6188 .dimensions = {5, 2},
6189 .isIgnored = false,
6190 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6191 .numberOfConsumers = 0,
6192 .scale = 0.0f,
6193 .type = TestOperandType::TENSOR_FLOAT32,
6194 .zeroPoint = 0
6195 }, { // op1_new
6196 .channelQuant = {},
6197 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
6198 .dimensions = {5, 2},
6199 .isIgnored = false,
6200 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6201 .numberOfConsumers = 1,
6202 .scale = 0.0f,
6203 .type = TestOperandType::TENSOR_FLOAT32,
6204 .zeroPoint = 0
6205 }, { // placeholder39
6206 .channelQuant = {},
6207 .data = TestBuffer::createFromVector<float>({0.0f}),
6208 .dimensions = {1},
6209 .isIgnored = false,
6210 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6211 .numberOfConsumers = 1,
6212 .scale = 0.0f,
6213 .type = TestOperandType::TENSOR_FLOAT32,
6214 .zeroPoint = 0
6215 }, { // param57
6216 .channelQuant = {},
6217 .data = TestBuffer::createFromVector<int32_t>({0}),
6218 .dimensions = {},
6219 .isIgnored = false,
6220 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6221 .numberOfConsumers = 1,
6222 .scale = 0.0f,
6223 .type = TestOperandType::INT32,
6224 .zeroPoint = 0
6225 }},
6226 .operations = {{
6227 .inputs = {4, 5, 6},
6228 .outputs = {0},
6229 .type = TestOperationType::ADD
6230 }, {
6231 .inputs = {0, 1, 2},
6232 .outputs = {3},
6233 .type = TestOperationType::SOFTMAX
6234 }},
6235 .outputIndexes = {3}
6236 },
6237 .minSupportedVersion = TestHalVersion::V1_2,
6238 .referenced = {}
6239 };
6240 return model;
6241 }
6242
6243 const auto dummy_test_model_axis_dim2_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0_neg_all_inputs_as_internal", get_test_model_axis_dim2_axis0_neg_all_inputs_as_internal());
6244
6245 } // namespace generated_tests::softmax_v1_2
6246
6247 namespace generated_tests::softmax_v1_2 {
6248
get_test_model_axis_dim2_axis1()6249 const TestModel& get_test_model_axis_dim2_axis1() {
6250 static TestModel model = {
6251 .expectFailure = false,
6252 .expectedMultinomialDistributionTolerance = 0,
6253 .isRelaxed = false,
6254 .main = { // axis
6255 .inputIndexes = {0},
6256 .operands = {{ // op1
6257 .channelQuant = {},
6258 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
6259 .dimensions = {2, 5},
6260 .isIgnored = false,
6261 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6262 .numberOfConsumers = 1,
6263 .scale = 0.0f,
6264 .type = TestOperandType::TENSOR_FLOAT32,
6265 .zeroPoint = 0
6266 }, { // param2
6267 .channelQuant = {},
6268 .data = TestBuffer::createFromVector<float>({1.0f}),
6269 .dimensions = {},
6270 .isIgnored = false,
6271 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6272 .numberOfConsumers = 1,
6273 .scale = 0.0f,
6274 .type = TestOperandType::FLOAT32,
6275 .zeroPoint = 0
6276 }, { // axis
6277 .channelQuant = {},
6278 .data = TestBuffer::createFromVector<int32_t>({1}),
6279 .dimensions = {},
6280 .isIgnored = false,
6281 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6282 .numberOfConsumers = 1,
6283 .scale = 0.0f,
6284 .type = TestOperandType::INT32,
6285 .zeroPoint = 0
6286 }, { // op2
6287 .channelQuant = {},
6288 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6289 .dimensions = {2, 5},
6290 .isIgnored = false,
6291 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6292 .numberOfConsumers = 0,
6293 .scale = 0.0f,
6294 .type = TestOperandType::TENSOR_FLOAT32,
6295 .zeroPoint = 0
6296 }},
6297 .operations = {{
6298 .inputs = {0, 1, 2},
6299 .outputs = {3},
6300 .type = TestOperationType::SOFTMAX
6301 }},
6302 .outputIndexes = {3}
6303 },
6304 .minSupportedVersion = TestHalVersion::V1_2,
6305 .referenced = {}
6306 };
6307 return model;
6308 }
6309
6310 const auto dummy_test_model_axis_dim2_axis1 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1", get_test_model_axis_dim2_axis1());
6311
6312 } // namespace generated_tests::softmax_v1_2
6313
6314 namespace generated_tests::softmax_v1_2 {
6315
get_test_model_axis_dim2_axis1_all_inputs_as_internal()6316 const TestModel& get_test_model_axis_dim2_axis1_all_inputs_as_internal() {
6317 static TestModel model = {
6318 .expectFailure = false,
6319 .expectedMultinomialDistributionTolerance = 0,
6320 .isRelaxed = false,
6321 .main = { // axis
6322 .inputIndexes = {4},
6323 .operands = {{ // op1
6324 .channelQuant = {},
6325 .data = TestBuffer::createFromVector<float>({}),
6326 .dimensions = {2, 5},
6327 .isIgnored = false,
6328 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6329 .numberOfConsumers = 1,
6330 .scale = 0.0f,
6331 .type = TestOperandType::TENSOR_FLOAT32,
6332 .zeroPoint = 0
6333 }, { // param2
6334 .channelQuant = {},
6335 .data = TestBuffer::createFromVector<float>({1.0f}),
6336 .dimensions = {},
6337 .isIgnored = false,
6338 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6339 .numberOfConsumers = 1,
6340 .scale = 0.0f,
6341 .type = TestOperandType::FLOAT32,
6342 .zeroPoint = 0
6343 }, { // axis
6344 .channelQuant = {},
6345 .data = TestBuffer::createFromVector<int32_t>({1}),
6346 .dimensions = {},
6347 .isIgnored = false,
6348 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6349 .numberOfConsumers = 1,
6350 .scale = 0.0f,
6351 .type = TestOperandType::INT32,
6352 .zeroPoint = 0
6353 }, { // op2
6354 .channelQuant = {},
6355 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6356 .dimensions = {2, 5},
6357 .isIgnored = false,
6358 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6359 .numberOfConsumers = 0,
6360 .scale = 0.0f,
6361 .type = TestOperandType::TENSOR_FLOAT32,
6362 .zeroPoint = 0
6363 }, { // op1_new
6364 .channelQuant = {},
6365 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
6366 .dimensions = {2, 5},
6367 .isIgnored = false,
6368 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6369 .numberOfConsumers = 1,
6370 .scale = 0.0f,
6371 .type = TestOperandType::TENSOR_FLOAT32,
6372 .zeroPoint = 0
6373 }, { // placeholder40
6374 .channelQuant = {},
6375 .data = TestBuffer::createFromVector<float>({0.0f}),
6376 .dimensions = {1},
6377 .isIgnored = false,
6378 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6379 .numberOfConsumers = 1,
6380 .scale = 0.0f,
6381 .type = TestOperandType::TENSOR_FLOAT32,
6382 .zeroPoint = 0
6383 }, { // param58
6384 .channelQuant = {},
6385 .data = TestBuffer::createFromVector<int32_t>({0}),
6386 .dimensions = {},
6387 .isIgnored = false,
6388 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6389 .numberOfConsumers = 1,
6390 .scale = 0.0f,
6391 .type = TestOperandType::INT32,
6392 .zeroPoint = 0
6393 }},
6394 .operations = {{
6395 .inputs = {4, 5, 6},
6396 .outputs = {0},
6397 .type = TestOperationType::ADD
6398 }, {
6399 .inputs = {0, 1, 2},
6400 .outputs = {3},
6401 .type = TestOperationType::SOFTMAX
6402 }},
6403 .outputIndexes = {3}
6404 },
6405 .minSupportedVersion = TestHalVersion::V1_2,
6406 .referenced = {}
6407 };
6408 return model;
6409 }
6410
6411 const auto dummy_test_model_axis_dim2_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1_all_inputs_as_internal", get_test_model_axis_dim2_axis1_all_inputs_as_internal());
6412
6413 } // namespace generated_tests::softmax_v1_2
6414
6415 namespace generated_tests::softmax_v1_2 {
6416
get_test_model_axis_dim2_axis1_neg()6417 const TestModel& get_test_model_axis_dim2_axis1_neg() {
6418 static TestModel model = {
6419 .expectFailure = false,
6420 .expectedMultinomialDistributionTolerance = 0,
6421 .isRelaxed = false,
6422 .main = { // axis
6423 .inputIndexes = {0},
6424 .operands = {{ // op1
6425 .channelQuant = {},
6426 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
6427 .dimensions = {2, 5},
6428 .isIgnored = false,
6429 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6430 .numberOfConsumers = 1,
6431 .scale = 0.0f,
6432 .type = TestOperandType::TENSOR_FLOAT32,
6433 .zeroPoint = 0
6434 }, { // param2
6435 .channelQuant = {},
6436 .data = TestBuffer::createFromVector<float>({1.0f}),
6437 .dimensions = {},
6438 .isIgnored = false,
6439 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6440 .numberOfConsumers = 1,
6441 .scale = 0.0f,
6442 .type = TestOperandType::FLOAT32,
6443 .zeroPoint = 0
6444 }, { // axis
6445 .channelQuant = {},
6446 .data = TestBuffer::createFromVector<int32_t>({-1}),
6447 .dimensions = {},
6448 .isIgnored = false,
6449 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6450 .numberOfConsumers = 1,
6451 .scale = 0.0f,
6452 .type = TestOperandType::INT32,
6453 .zeroPoint = 0
6454 }, { // op2
6455 .channelQuant = {},
6456 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6457 .dimensions = {2, 5},
6458 .isIgnored = false,
6459 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6460 .numberOfConsumers = 0,
6461 .scale = 0.0f,
6462 .type = TestOperandType::TENSOR_FLOAT32,
6463 .zeroPoint = 0
6464 }},
6465 .operations = {{
6466 .inputs = {0, 1, 2},
6467 .outputs = {3},
6468 .type = TestOperationType::SOFTMAX
6469 }},
6470 .outputIndexes = {3}
6471 },
6472 .minSupportedVersion = TestHalVersion::V1_0,
6473 .referenced = {}
6474 };
6475 return model;
6476 }
6477
6478 const auto dummy_test_model_axis_dim2_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1_neg", get_test_model_axis_dim2_axis1_neg());
6479
6480 } // namespace generated_tests::softmax_v1_2
6481
6482 namespace generated_tests::softmax_v1_2 {
6483
get_test_model_axis_dim2_axis1_neg_all_inputs_as_internal()6484 const TestModel& get_test_model_axis_dim2_axis1_neg_all_inputs_as_internal() {
6485 static TestModel model = {
6486 .expectFailure = false,
6487 .expectedMultinomialDistributionTolerance = 0,
6488 .isRelaxed = false,
6489 .main = { // axis
6490 .inputIndexes = {4},
6491 .operands = {{ // op1
6492 .channelQuant = {},
6493 .data = TestBuffer::createFromVector<float>({}),
6494 .dimensions = {2, 5},
6495 .isIgnored = false,
6496 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6497 .numberOfConsumers = 1,
6498 .scale = 0.0f,
6499 .type = TestOperandType::TENSOR_FLOAT32,
6500 .zeroPoint = 0
6501 }, { // param2
6502 .channelQuant = {},
6503 .data = TestBuffer::createFromVector<float>({1.0f}),
6504 .dimensions = {},
6505 .isIgnored = false,
6506 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6507 .numberOfConsumers = 1,
6508 .scale = 0.0f,
6509 .type = TestOperandType::FLOAT32,
6510 .zeroPoint = 0
6511 }, { // axis
6512 .channelQuant = {},
6513 .data = TestBuffer::createFromVector<int32_t>({-1}),
6514 .dimensions = {},
6515 .isIgnored = false,
6516 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6517 .numberOfConsumers = 1,
6518 .scale = 0.0f,
6519 .type = TestOperandType::INT32,
6520 .zeroPoint = 0
6521 }, { // op2
6522 .channelQuant = {},
6523 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6524 .dimensions = {2, 5},
6525 .isIgnored = false,
6526 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6527 .numberOfConsumers = 0,
6528 .scale = 0.0f,
6529 .type = TestOperandType::TENSOR_FLOAT32,
6530 .zeroPoint = 0
6531 }, { // op1_new
6532 .channelQuant = {},
6533 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
6534 .dimensions = {2, 5},
6535 .isIgnored = false,
6536 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6537 .numberOfConsumers = 1,
6538 .scale = 0.0f,
6539 .type = TestOperandType::TENSOR_FLOAT32,
6540 .zeroPoint = 0
6541 }, { // placeholder41
6542 .channelQuant = {},
6543 .data = TestBuffer::createFromVector<float>({0.0f}),
6544 .dimensions = {1},
6545 .isIgnored = false,
6546 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6547 .numberOfConsumers = 1,
6548 .scale = 0.0f,
6549 .type = TestOperandType::TENSOR_FLOAT32,
6550 .zeroPoint = 0
6551 }, { // param59
6552 .channelQuant = {},
6553 .data = TestBuffer::createFromVector<int32_t>({0}),
6554 .dimensions = {},
6555 .isIgnored = false,
6556 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6557 .numberOfConsumers = 1,
6558 .scale = 0.0f,
6559 .type = TestOperandType::INT32,
6560 .zeroPoint = 0
6561 }},
6562 .operations = {{
6563 .inputs = {4, 5, 6},
6564 .outputs = {0},
6565 .type = TestOperationType::ADD
6566 }, {
6567 .inputs = {0, 1, 2},
6568 .outputs = {3},
6569 .type = TestOperationType::SOFTMAX
6570 }},
6571 .outputIndexes = {3}
6572 },
6573 .minSupportedVersion = TestHalVersion::V1_0,
6574 .referenced = {}
6575 };
6576 return model;
6577 }
6578
6579 const auto dummy_test_model_axis_dim2_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1_neg_all_inputs_as_internal", get_test_model_axis_dim2_axis1_neg_all_inputs_as_internal());
6580
6581 } // namespace generated_tests::softmax_v1_2
6582
6583 namespace generated_tests::softmax_v1_2 {
6584
get_test_model_axis_dim1_axis0()6585 const TestModel& get_test_model_axis_dim1_axis0() {
6586 static TestModel model = {
6587 .expectFailure = false,
6588 .expectedMultinomialDistributionTolerance = 0,
6589 .isRelaxed = false,
6590 .main = { // axis
6591 .inputIndexes = {0},
6592 .operands = {{ // op1
6593 .channelQuant = {},
6594 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
6595 .dimensions = {5},
6596 .isIgnored = false,
6597 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6598 .numberOfConsumers = 1,
6599 .scale = 0.0f,
6600 .type = TestOperandType::TENSOR_FLOAT32,
6601 .zeroPoint = 0
6602 }, { // param2
6603 .channelQuant = {},
6604 .data = TestBuffer::createFromVector<float>({1.0f}),
6605 .dimensions = {},
6606 .isIgnored = false,
6607 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6608 .numberOfConsumers = 1,
6609 .scale = 0.0f,
6610 .type = TestOperandType::FLOAT32,
6611 .zeroPoint = 0
6612 }, { // axis
6613 .channelQuant = {},
6614 .data = TestBuffer::createFromVector<int32_t>({0}),
6615 .dimensions = {},
6616 .isIgnored = false,
6617 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6618 .numberOfConsumers = 1,
6619 .scale = 0.0f,
6620 .type = TestOperandType::INT32,
6621 .zeroPoint = 0
6622 }, { // op2
6623 .channelQuant = {},
6624 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6625 .dimensions = {5},
6626 .isIgnored = false,
6627 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6628 .numberOfConsumers = 0,
6629 .scale = 0.0f,
6630 .type = TestOperandType::TENSOR_FLOAT32,
6631 .zeroPoint = 0
6632 }},
6633 .operations = {{
6634 .inputs = {0, 1, 2},
6635 .outputs = {3},
6636 .type = TestOperationType::SOFTMAX
6637 }},
6638 .outputIndexes = {3}
6639 },
6640 .minSupportedVersion = TestHalVersion::V1_2,
6641 .referenced = {}
6642 };
6643 return model;
6644 }
6645
6646 const auto dummy_test_model_axis_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0", get_test_model_axis_dim1_axis0());
6647
6648 } // namespace generated_tests::softmax_v1_2
6649
6650 namespace generated_tests::softmax_v1_2 {
6651
get_test_model_axis_dim1_axis0_all_inputs_as_internal()6652 const TestModel& get_test_model_axis_dim1_axis0_all_inputs_as_internal() {
6653 static TestModel model = {
6654 .expectFailure = false,
6655 .expectedMultinomialDistributionTolerance = 0,
6656 .isRelaxed = false,
6657 .main = { // axis
6658 .inputIndexes = {4},
6659 .operands = {{ // op1
6660 .channelQuant = {},
6661 .data = TestBuffer::createFromVector<float>({}),
6662 .dimensions = {5},
6663 .isIgnored = false,
6664 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6665 .numberOfConsumers = 1,
6666 .scale = 0.0f,
6667 .type = TestOperandType::TENSOR_FLOAT32,
6668 .zeroPoint = 0
6669 }, { // param2
6670 .channelQuant = {},
6671 .data = TestBuffer::createFromVector<float>({1.0f}),
6672 .dimensions = {},
6673 .isIgnored = false,
6674 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6675 .numberOfConsumers = 1,
6676 .scale = 0.0f,
6677 .type = TestOperandType::FLOAT32,
6678 .zeroPoint = 0
6679 }, { // axis
6680 .channelQuant = {},
6681 .data = TestBuffer::createFromVector<int32_t>({0}),
6682 .dimensions = {},
6683 .isIgnored = false,
6684 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6685 .numberOfConsumers = 1,
6686 .scale = 0.0f,
6687 .type = TestOperandType::INT32,
6688 .zeroPoint = 0
6689 }, { // op2
6690 .channelQuant = {},
6691 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6692 .dimensions = {5},
6693 .isIgnored = false,
6694 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6695 .numberOfConsumers = 0,
6696 .scale = 0.0f,
6697 .type = TestOperandType::TENSOR_FLOAT32,
6698 .zeroPoint = 0
6699 }, { // op1_new
6700 .channelQuant = {},
6701 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
6702 .dimensions = {5},
6703 .isIgnored = false,
6704 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6705 .numberOfConsumers = 1,
6706 .scale = 0.0f,
6707 .type = TestOperandType::TENSOR_FLOAT32,
6708 .zeroPoint = 0
6709 }, { // placeholder42
6710 .channelQuant = {},
6711 .data = TestBuffer::createFromVector<float>({0.0f}),
6712 .dimensions = {1},
6713 .isIgnored = false,
6714 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6715 .numberOfConsumers = 1,
6716 .scale = 0.0f,
6717 .type = TestOperandType::TENSOR_FLOAT32,
6718 .zeroPoint = 0
6719 }, { // param60
6720 .channelQuant = {},
6721 .data = TestBuffer::createFromVector<int32_t>({0}),
6722 .dimensions = {},
6723 .isIgnored = false,
6724 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6725 .numberOfConsumers = 1,
6726 .scale = 0.0f,
6727 .type = TestOperandType::INT32,
6728 .zeroPoint = 0
6729 }},
6730 .operations = {{
6731 .inputs = {4, 5, 6},
6732 .outputs = {0},
6733 .type = TestOperationType::ADD
6734 }, {
6735 .inputs = {0, 1, 2},
6736 .outputs = {3},
6737 .type = TestOperationType::SOFTMAX
6738 }},
6739 .outputIndexes = {3}
6740 },
6741 .minSupportedVersion = TestHalVersion::V1_2,
6742 .referenced = {}
6743 };
6744 return model;
6745 }
6746
6747 const auto dummy_test_model_axis_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0_all_inputs_as_internal", get_test_model_axis_dim1_axis0_all_inputs_as_internal());
6748
6749 } // namespace generated_tests::softmax_v1_2
6750
6751 namespace generated_tests::softmax_v1_2 {
6752
get_test_model_axis_dim1_axis0_neg()6753 const TestModel& get_test_model_axis_dim1_axis0_neg() {
6754 static TestModel model = {
6755 .expectFailure = false,
6756 .expectedMultinomialDistributionTolerance = 0,
6757 .isRelaxed = false,
6758 .main = { // axis
6759 .inputIndexes = {0},
6760 .operands = {{ // op1
6761 .channelQuant = {},
6762 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
6763 .dimensions = {5},
6764 .isIgnored = false,
6765 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6766 .numberOfConsumers = 1,
6767 .scale = 0.0f,
6768 .type = TestOperandType::TENSOR_FLOAT32,
6769 .zeroPoint = 0
6770 }, { // param2
6771 .channelQuant = {},
6772 .data = TestBuffer::createFromVector<float>({1.0f}),
6773 .dimensions = {},
6774 .isIgnored = false,
6775 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6776 .numberOfConsumers = 1,
6777 .scale = 0.0f,
6778 .type = TestOperandType::FLOAT32,
6779 .zeroPoint = 0
6780 }, { // axis
6781 .channelQuant = {},
6782 .data = TestBuffer::createFromVector<int32_t>({-1}),
6783 .dimensions = {},
6784 .isIgnored = false,
6785 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6786 .numberOfConsumers = 1,
6787 .scale = 0.0f,
6788 .type = TestOperandType::INT32,
6789 .zeroPoint = 0
6790 }, { // op2
6791 .channelQuant = {},
6792 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6793 .dimensions = {5},
6794 .isIgnored = false,
6795 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6796 .numberOfConsumers = 0,
6797 .scale = 0.0f,
6798 .type = TestOperandType::TENSOR_FLOAT32,
6799 .zeroPoint = 0
6800 }},
6801 .operations = {{
6802 .inputs = {0, 1, 2},
6803 .outputs = {3},
6804 .type = TestOperationType::SOFTMAX
6805 }},
6806 .outputIndexes = {3}
6807 },
6808 .minSupportedVersion = TestHalVersion::V1_2,
6809 .referenced = {}
6810 };
6811 return model;
6812 }
6813
6814 const auto dummy_test_model_axis_dim1_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0_neg", get_test_model_axis_dim1_axis0_neg());
6815
6816 } // namespace generated_tests::softmax_v1_2
6817
6818 namespace generated_tests::softmax_v1_2 {
6819
get_test_model_axis_dim1_axis0_neg_all_inputs_as_internal()6820 const TestModel& get_test_model_axis_dim1_axis0_neg_all_inputs_as_internal() {
6821 static TestModel model = {
6822 .expectFailure = false,
6823 .expectedMultinomialDistributionTolerance = 0,
6824 .isRelaxed = false,
6825 .main = { // axis
6826 .inputIndexes = {4},
6827 .operands = {{ // op1
6828 .channelQuant = {},
6829 .data = TestBuffer::createFromVector<float>({}),
6830 .dimensions = {5},
6831 .isIgnored = false,
6832 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6833 .numberOfConsumers = 1,
6834 .scale = 0.0f,
6835 .type = TestOperandType::TENSOR_FLOAT32,
6836 .zeroPoint = 0
6837 }, { // param2
6838 .channelQuant = {},
6839 .data = TestBuffer::createFromVector<float>({1.0f}),
6840 .dimensions = {},
6841 .isIgnored = false,
6842 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6843 .numberOfConsumers = 1,
6844 .scale = 0.0f,
6845 .type = TestOperandType::FLOAT32,
6846 .zeroPoint = 0
6847 }, { // axis
6848 .channelQuant = {},
6849 .data = TestBuffer::createFromVector<int32_t>({-1}),
6850 .dimensions = {},
6851 .isIgnored = false,
6852 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6853 .numberOfConsumers = 1,
6854 .scale = 0.0f,
6855 .type = TestOperandType::INT32,
6856 .zeroPoint = 0
6857 }, { // op2
6858 .channelQuant = {},
6859 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
6860 .dimensions = {5},
6861 .isIgnored = false,
6862 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6863 .numberOfConsumers = 0,
6864 .scale = 0.0f,
6865 .type = TestOperandType::TENSOR_FLOAT32,
6866 .zeroPoint = 0
6867 }, { // op1_new
6868 .channelQuant = {},
6869 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
6870 .dimensions = {5},
6871 .isIgnored = false,
6872 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6873 .numberOfConsumers = 1,
6874 .scale = 0.0f,
6875 .type = TestOperandType::TENSOR_FLOAT32,
6876 .zeroPoint = 0
6877 }, { // placeholder43
6878 .channelQuant = {},
6879 .data = TestBuffer::createFromVector<float>({0.0f}),
6880 .dimensions = {1},
6881 .isIgnored = false,
6882 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6883 .numberOfConsumers = 1,
6884 .scale = 0.0f,
6885 .type = TestOperandType::TENSOR_FLOAT32,
6886 .zeroPoint = 0
6887 }, { // param61
6888 .channelQuant = {},
6889 .data = TestBuffer::createFromVector<int32_t>({0}),
6890 .dimensions = {},
6891 .isIgnored = false,
6892 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6893 .numberOfConsumers = 1,
6894 .scale = 0.0f,
6895 .type = TestOperandType::INT32,
6896 .zeroPoint = 0
6897 }},
6898 .operations = {{
6899 .inputs = {4, 5, 6},
6900 .outputs = {0},
6901 .type = TestOperationType::ADD
6902 }, {
6903 .inputs = {0, 1, 2},
6904 .outputs = {3},
6905 .type = TestOperationType::SOFTMAX
6906 }},
6907 .outputIndexes = {3}
6908 },
6909 .minSupportedVersion = TestHalVersion::V1_2,
6910 .referenced = {}
6911 };
6912 return model;
6913 }
6914
6915 const auto dummy_test_model_axis_dim1_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0_neg_all_inputs_as_internal", get_test_model_axis_dim1_axis0_neg_all_inputs_as_internal());
6916
6917 } // namespace generated_tests::softmax_v1_2
6918
6919 namespace generated_tests::softmax_v1_2 {
6920
get_test_model_axis_relaxed_dim4_axis0()6921 const TestModel& get_test_model_axis_relaxed_dim4_axis0() {
6922 static TestModel model = {
6923 .expectFailure = false,
6924 .expectedMultinomialDistributionTolerance = 0,
6925 .isRelaxed = true,
6926 .main = { // axis
6927 .inputIndexes = {0},
6928 .operands = {{ // op1
6929 .channelQuant = {},
6930 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
6931 .dimensions = {5, 2, 2, 2},
6932 .isIgnored = false,
6933 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6934 .numberOfConsumers = 1,
6935 .scale = 0.0f,
6936 .type = TestOperandType::TENSOR_FLOAT32,
6937 .zeroPoint = 0
6938 }, { // param2
6939 .channelQuant = {},
6940 .data = TestBuffer::createFromVector<float>({1.0f}),
6941 .dimensions = {},
6942 .isIgnored = false,
6943 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6944 .numberOfConsumers = 1,
6945 .scale = 0.0f,
6946 .type = TestOperandType::FLOAT32,
6947 .zeroPoint = 0
6948 }, { // axis
6949 .channelQuant = {},
6950 .data = TestBuffer::createFromVector<int32_t>({0}),
6951 .dimensions = {},
6952 .isIgnored = false,
6953 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6954 .numberOfConsumers = 1,
6955 .scale = 0.0f,
6956 .type = TestOperandType::INT32,
6957 .zeroPoint = 0
6958 }, { // op2
6959 .channelQuant = {},
6960 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
6961 .dimensions = {5, 2, 2, 2},
6962 .isIgnored = false,
6963 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6964 .numberOfConsumers = 0,
6965 .scale = 0.0f,
6966 .type = TestOperandType::TENSOR_FLOAT32,
6967 .zeroPoint = 0
6968 }},
6969 .operations = {{
6970 .inputs = {0, 1, 2},
6971 .outputs = {3},
6972 .type = TestOperationType::SOFTMAX
6973 }},
6974 .outputIndexes = {3}
6975 },
6976 .minSupportedVersion = TestHalVersion::UNKNOWN,
6977 .referenced = {}
6978 };
6979 return model;
6980 }
6981
6982 const auto dummy_test_model_axis_relaxed_dim4_axis0 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0", get_test_model_axis_relaxed_dim4_axis0());
6983
6984 } // namespace generated_tests::softmax_v1_2
6985
6986 namespace generated_tests::softmax_v1_2 {
6987
get_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal()6988 const TestModel& get_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal() {
6989 static TestModel model = {
6990 .expectFailure = false,
6991 .expectedMultinomialDistributionTolerance = 0,
6992 .isRelaxed = true,
6993 .main = { // axis
6994 .inputIndexes = {4},
6995 .operands = {{ // op1
6996 .channelQuant = {},
6997 .data = TestBuffer::createFromVector<float>({}),
6998 .dimensions = {5, 2, 2, 2},
6999 .isIgnored = false,
7000 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7001 .numberOfConsumers = 1,
7002 .scale = 0.0f,
7003 .type = TestOperandType::TENSOR_FLOAT32,
7004 .zeroPoint = 0
7005 }, { // param2
7006 .channelQuant = {},
7007 .data = TestBuffer::createFromVector<float>({1.0f}),
7008 .dimensions = {},
7009 .isIgnored = false,
7010 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7011 .numberOfConsumers = 1,
7012 .scale = 0.0f,
7013 .type = TestOperandType::FLOAT32,
7014 .zeroPoint = 0
7015 }, { // axis
7016 .channelQuant = {},
7017 .data = TestBuffer::createFromVector<int32_t>({0}),
7018 .dimensions = {},
7019 .isIgnored = false,
7020 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7021 .numberOfConsumers = 1,
7022 .scale = 0.0f,
7023 .type = TestOperandType::INT32,
7024 .zeroPoint = 0
7025 }, { // op2
7026 .channelQuant = {},
7027 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7028 .dimensions = {5, 2, 2, 2},
7029 .isIgnored = false,
7030 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7031 .numberOfConsumers = 0,
7032 .scale = 0.0f,
7033 .type = TestOperandType::TENSOR_FLOAT32,
7034 .zeroPoint = 0
7035 }, { // op1_new
7036 .channelQuant = {},
7037 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
7038 .dimensions = {5, 2, 2, 2},
7039 .isIgnored = false,
7040 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7041 .numberOfConsumers = 1,
7042 .scale = 0.0f,
7043 .type = TestOperandType::TENSOR_FLOAT32,
7044 .zeroPoint = 0
7045 }, { // placeholder44
7046 .channelQuant = {},
7047 .data = TestBuffer::createFromVector<float>({0.0f}),
7048 .dimensions = {1},
7049 .isIgnored = false,
7050 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7051 .numberOfConsumers = 1,
7052 .scale = 0.0f,
7053 .type = TestOperandType::TENSOR_FLOAT32,
7054 .zeroPoint = 0
7055 }, { // param62
7056 .channelQuant = {},
7057 .data = TestBuffer::createFromVector<int32_t>({0}),
7058 .dimensions = {},
7059 .isIgnored = false,
7060 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7061 .numberOfConsumers = 1,
7062 .scale = 0.0f,
7063 .type = TestOperandType::INT32,
7064 .zeroPoint = 0
7065 }},
7066 .operations = {{
7067 .inputs = {4, 5, 6},
7068 .outputs = {0},
7069 .type = TestOperationType::ADD
7070 }, {
7071 .inputs = {0, 1, 2},
7072 .outputs = {3},
7073 .type = TestOperationType::SOFTMAX
7074 }},
7075 .outputIndexes = {3}
7076 },
7077 .minSupportedVersion = TestHalVersion::UNKNOWN,
7078 .referenced = {}
7079 };
7080 return model;
7081 }
7082
7083 const auto dummy_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal());
7084
7085 } // namespace generated_tests::softmax_v1_2
7086
7087 namespace generated_tests::softmax_v1_2 {
7088
get_test_model_axis_relaxed_dim4_axis0_neg()7089 const TestModel& get_test_model_axis_relaxed_dim4_axis0_neg() {
7090 static TestModel model = {
7091 .expectFailure = false,
7092 .expectedMultinomialDistributionTolerance = 0,
7093 .isRelaxed = true,
7094 .main = { // axis
7095 .inputIndexes = {0},
7096 .operands = {{ // op1
7097 .channelQuant = {},
7098 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
7099 .dimensions = {5, 2, 2, 2},
7100 .isIgnored = false,
7101 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7102 .numberOfConsumers = 1,
7103 .scale = 0.0f,
7104 .type = TestOperandType::TENSOR_FLOAT32,
7105 .zeroPoint = 0
7106 }, { // param2
7107 .channelQuant = {},
7108 .data = TestBuffer::createFromVector<float>({1.0f}),
7109 .dimensions = {},
7110 .isIgnored = false,
7111 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7112 .numberOfConsumers = 1,
7113 .scale = 0.0f,
7114 .type = TestOperandType::FLOAT32,
7115 .zeroPoint = 0
7116 }, { // axis
7117 .channelQuant = {},
7118 .data = TestBuffer::createFromVector<int32_t>({-4}),
7119 .dimensions = {},
7120 .isIgnored = false,
7121 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7122 .numberOfConsumers = 1,
7123 .scale = 0.0f,
7124 .type = TestOperandType::INT32,
7125 .zeroPoint = 0
7126 }, { // op2
7127 .channelQuant = {},
7128 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7129 .dimensions = {5, 2, 2, 2},
7130 .isIgnored = false,
7131 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7132 .numberOfConsumers = 0,
7133 .scale = 0.0f,
7134 .type = TestOperandType::TENSOR_FLOAT32,
7135 .zeroPoint = 0
7136 }},
7137 .operations = {{
7138 .inputs = {0, 1, 2},
7139 .outputs = {3},
7140 .type = TestOperationType::SOFTMAX
7141 }},
7142 .outputIndexes = {3}
7143 },
7144 .minSupportedVersion = TestHalVersion::UNKNOWN,
7145 .referenced = {}
7146 };
7147 return model;
7148 }
7149
7150 const auto dummy_test_model_axis_relaxed_dim4_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0_neg", get_test_model_axis_relaxed_dim4_axis0_neg());
7151
7152 } // namespace generated_tests::softmax_v1_2
7153
7154 namespace generated_tests::softmax_v1_2 {
7155
get_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal()7156 const TestModel& get_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal() {
7157 static TestModel model = {
7158 .expectFailure = false,
7159 .expectedMultinomialDistributionTolerance = 0,
7160 .isRelaxed = true,
7161 .main = { // axis
7162 .inputIndexes = {4},
7163 .operands = {{ // op1
7164 .channelQuant = {},
7165 .data = TestBuffer::createFromVector<float>({}),
7166 .dimensions = {5, 2, 2, 2},
7167 .isIgnored = false,
7168 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7169 .numberOfConsumers = 1,
7170 .scale = 0.0f,
7171 .type = TestOperandType::TENSOR_FLOAT32,
7172 .zeroPoint = 0
7173 }, { // param2
7174 .channelQuant = {},
7175 .data = TestBuffer::createFromVector<float>({1.0f}),
7176 .dimensions = {},
7177 .isIgnored = false,
7178 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7179 .numberOfConsumers = 1,
7180 .scale = 0.0f,
7181 .type = TestOperandType::FLOAT32,
7182 .zeroPoint = 0
7183 }, { // axis
7184 .channelQuant = {},
7185 .data = TestBuffer::createFromVector<int32_t>({-4}),
7186 .dimensions = {},
7187 .isIgnored = false,
7188 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7189 .numberOfConsumers = 1,
7190 .scale = 0.0f,
7191 .type = TestOperandType::INT32,
7192 .zeroPoint = 0
7193 }, { // op2
7194 .channelQuant = {},
7195 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7196 .dimensions = {5, 2, 2, 2},
7197 .isIgnored = false,
7198 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7199 .numberOfConsumers = 0,
7200 .scale = 0.0f,
7201 .type = TestOperandType::TENSOR_FLOAT32,
7202 .zeroPoint = 0
7203 }, { // op1_new
7204 .channelQuant = {},
7205 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
7206 .dimensions = {5, 2, 2, 2},
7207 .isIgnored = false,
7208 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7209 .numberOfConsumers = 1,
7210 .scale = 0.0f,
7211 .type = TestOperandType::TENSOR_FLOAT32,
7212 .zeroPoint = 0
7213 }, { // placeholder45
7214 .channelQuant = {},
7215 .data = TestBuffer::createFromVector<float>({0.0f}),
7216 .dimensions = {1},
7217 .isIgnored = false,
7218 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7219 .numberOfConsumers = 1,
7220 .scale = 0.0f,
7221 .type = TestOperandType::TENSOR_FLOAT32,
7222 .zeroPoint = 0
7223 }, { // param63
7224 .channelQuant = {},
7225 .data = TestBuffer::createFromVector<int32_t>({0}),
7226 .dimensions = {},
7227 .isIgnored = false,
7228 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7229 .numberOfConsumers = 1,
7230 .scale = 0.0f,
7231 .type = TestOperandType::INT32,
7232 .zeroPoint = 0
7233 }},
7234 .operations = {{
7235 .inputs = {4, 5, 6},
7236 .outputs = {0},
7237 .type = TestOperationType::ADD
7238 }, {
7239 .inputs = {0, 1, 2},
7240 .outputs = {3},
7241 .type = TestOperationType::SOFTMAX
7242 }},
7243 .outputIndexes = {3}
7244 },
7245 .minSupportedVersion = TestHalVersion::UNKNOWN,
7246 .referenced = {}
7247 };
7248 return model;
7249 }
7250
7251 const auto dummy_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal());
7252
7253 } // namespace generated_tests::softmax_v1_2
7254
7255 namespace generated_tests::softmax_v1_2 {
7256
get_test_model_axis_relaxed_dim4_axis1()7257 const TestModel& get_test_model_axis_relaxed_dim4_axis1() {
7258 static TestModel model = {
7259 .expectFailure = false,
7260 .expectedMultinomialDistributionTolerance = 0,
7261 .isRelaxed = true,
7262 .main = { // axis
7263 .inputIndexes = {0},
7264 .operands = {{ // op1
7265 .channelQuant = {},
7266 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
7267 .dimensions = {2, 5, 2, 2},
7268 .isIgnored = false,
7269 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7270 .numberOfConsumers = 1,
7271 .scale = 0.0f,
7272 .type = TestOperandType::TENSOR_FLOAT32,
7273 .zeroPoint = 0
7274 }, { // param2
7275 .channelQuant = {},
7276 .data = TestBuffer::createFromVector<float>({1.0f}),
7277 .dimensions = {},
7278 .isIgnored = false,
7279 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7280 .numberOfConsumers = 1,
7281 .scale = 0.0f,
7282 .type = TestOperandType::FLOAT32,
7283 .zeroPoint = 0
7284 }, { // axis
7285 .channelQuant = {},
7286 .data = TestBuffer::createFromVector<int32_t>({1}),
7287 .dimensions = {},
7288 .isIgnored = false,
7289 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7290 .numberOfConsumers = 1,
7291 .scale = 0.0f,
7292 .type = TestOperandType::INT32,
7293 .zeroPoint = 0
7294 }, { // op2
7295 .channelQuant = {},
7296 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7297 .dimensions = {2, 5, 2, 2},
7298 .isIgnored = false,
7299 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7300 .numberOfConsumers = 0,
7301 .scale = 0.0f,
7302 .type = TestOperandType::TENSOR_FLOAT32,
7303 .zeroPoint = 0
7304 }},
7305 .operations = {{
7306 .inputs = {0, 1, 2},
7307 .outputs = {3},
7308 .type = TestOperationType::SOFTMAX
7309 }},
7310 .outputIndexes = {3}
7311 },
7312 .minSupportedVersion = TestHalVersion::UNKNOWN,
7313 .referenced = {}
7314 };
7315 return model;
7316 }
7317
7318 const auto dummy_test_model_axis_relaxed_dim4_axis1 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1", get_test_model_axis_relaxed_dim4_axis1());
7319
7320 } // namespace generated_tests::softmax_v1_2
7321
7322 namespace generated_tests::softmax_v1_2 {
7323
get_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal()7324 const TestModel& get_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal() {
7325 static TestModel model = {
7326 .expectFailure = false,
7327 .expectedMultinomialDistributionTolerance = 0,
7328 .isRelaxed = true,
7329 .main = { // axis
7330 .inputIndexes = {4},
7331 .operands = {{ // op1
7332 .channelQuant = {},
7333 .data = TestBuffer::createFromVector<float>({}),
7334 .dimensions = {2, 5, 2, 2},
7335 .isIgnored = false,
7336 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7337 .numberOfConsumers = 1,
7338 .scale = 0.0f,
7339 .type = TestOperandType::TENSOR_FLOAT32,
7340 .zeroPoint = 0
7341 }, { // param2
7342 .channelQuant = {},
7343 .data = TestBuffer::createFromVector<float>({1.0f}),
7344 .dimensions = {},
7345 .isIgnored = false,
7346 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7347 .numberOfConsumers = 1,
7348 .scale = 0.0f,
7349 .type = TestOperandType::FLOAT32,
7350 .zeroPoint = 0
7351 }, { // axis
7352 .channelQuant = {},
7353 .data = TestBuffer::createFromVector<int32_t>({1}),
7354 .dimensions = {},
7355 .isIgnored = false,
7356 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7357 .numberOfConsumers = 1,
7358 .scale = 0.0f,
7359 .type = TestOperandType::INT32,
7360 .zeroPoint = 0
7361 }, { // op2
7362 .channelQuant = {},
7363 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7364 .dimensions = {2, 5, 2, 2},
7365 .isIgnored = false,
7366 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7367 .numberOfConsumers = 0,
7368 .scale = 0.0f,
7369 .type = TestOperandType::TENSOR_FLOAT32,
7370 .zeroPoint = 0
7371 }, { // op1_new
7372 .channelQuant = {},
7373 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
7374 .dimensions = {2, 5, 2, 2},
7375 .isIgnored = false,
7376 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7377 .numberOfConsumers = 1,
7378 .scale = 0.0f,
7379 .type = TestOperandType::TENSOR_FLOAT32,
7380 .zeroPoint = 0
7381 }, { // placeholder46
7382 .channelQuant = {},
7383 .data = TestBuffer::createFromVector<float>({0.0f}),
7384 .dimensions = {1},
7385 .isIgnored = false,
7386 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7387 .numberOfConsumers = 1,
7388 .scale = 0.0f,
7389 .type = TestOperandType::TENSOR_FLOAT32,
7390 .zeroPoint = 0
7391 }, { // param64
7392 .channelQuant = {},
7393 .data = TestBuffer::createFromVector<int32_t>({0}),
7394 .dimensions = {},
7395 .isIgnored = false,
7396 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7397 .numberOfConsumers = 1,
7398 .scale = 0.0f,
7399 .type = TestOperandType::INT32,
7400 .zeroPoint = 0
7401 }},
7402 .operations = {{
7403 .inputs = {4, 5, 6},
7404 .outputs = {0},
7405 .type = TestOperationType::ADD
7406 }, {
7407 .inputs = {0, 1, 2},
7408 .outputs = {3},
7409 .type = TestOperationType::SOFTMAX
7410 }},
7411 .outputIndexes = {3}
7412 },
7413 .minSupportedVersion = TestHalVersion::UNKNOWN,
7414 .referenced = {}
7415 };
7416 return model;
7417 }
7418
7419 const auto dummy_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal());
7420
7421 } // namespace generated_tests::softmax_v1_2
7422
7423 namespace generated_tests::softmax_v1_2 {
7424
get_test_model_axis_relaxed_dim4_axis1_neg()7425 const TestModel& get_test_model_axis_relaxed_dim4_axis1_neg() {
7426 static TestModel model = {
7427 .expectFailure = false,
7428 .expectedMultinomialDistributionTolerance = 0,
7429 .isRelaxed = true,
7430 .main = { // axis
7431 .inputIndexes = {0},
7432 .operands = {{ // op1
7433 .channelQuant = {},
7434 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
7435 .dimensions = {2, 5, 2, 2},
7436 .isIgnored = false,
7437 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7438 .numberOfConsumers = 1,
7439 .scale = 0.0f,
7440 .type = TestOperandType::TENSOR_FLOAT32,
7441 .zeroPoint = 0
7442 }, { // param2
7443 .channelQuant = {},
7444 .data = TestBuffer::createFromVector<float>({1.0f}),
7445 .dimensions = {},
7446 .isIgnored = false,
7447 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7448 .numberOfConsumers = 1,
7449 .scale = 0.0f,
7450 .type = TestOperandType::FLOAT32,
7451 .zeroPoint = 0
7452 }, { // axis
7453 .channelQuant = {},
7454 .data = TestBuffer::createFromVector<int32_t>({-3}),
7455 .dimensions = {},
7456 .isIgnored = false,
7457 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7458 .numberOfConsumers = 1,
7459 .scale = 0.0f,
7460 .type = TestOperandType::INT32,
7461 .zeroPoint = 0
7462 }, { // op2
7463 .channelQuant = {},
7464 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7465 .dimensions = {2, 5, 2, 2},
7466 .isIgnored = false,
7467 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7468 .numberOfConsumers = 0,
7469 .scale = 0.0f,
7470 .type = TestOperandType::TENSOR_FLOAT32,
7471 .zeroPoint = 0
7472 }},
7473 .operations = {{
7474 .inputs = {0, 1, 2},
7475 .outputs = {3},
7476 .type = TestOperationType::SOFTMAX
7477 }},
7478 .outputIndexes = {3}
7479 },
7480 .minSupportedVersion = TestHalVersion::UNKNOWN,
7481 .referenced = {}
7482 };
7483 return model;
7484 }
7485
7486 const auto dummy_test_model_axis_relaxed_dim4_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1_neg", get_test_model_axis_relaxed_dim4_axis1_neg());
7487
7488 } // namespace generated_tests::softmax_v1_2
7489
7490 namespace generated_tests::softmax_v1_2 {
7491
get_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal()7492 const TestModel& get_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal() {
7493 static TestModel model = {
7494 .expectFailure = false,
7495 .expectedMultinomialDistributionTolerance = 0,
7496 .isRelaxed = true,
7497 .main = { // axis
7498 .inputIndexes = {4},
7499 .operands = {{ // op1
7500 .channelQuant = {},
7501 .data = TestBuffer::createFromVector<float>({}),
7502 .dimensions = {2, 5, 2, 2},
7503 .isIgnored = false,
7504 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7505 .numberOfConsumers = 1,
7506 .scale = 0.0f,
7507 .type = TestOperandType::TENSOR_FLOAT32,
7508 .zeroPoint = 0
7509 }, { // param2
7510 .channelQuant = {},
7511 .data = TestBuffer::createFromVector<float>({1.0f}),
7512 .dimensions = {},
7513 .isIgnored = false,
7514 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7515 .numberOfConsumers = 1,
7516 .scale = 0.0f,
7517 .type = TestOperandType::FLOAT32,
7518 .zeroPoint = 0
7519 }, { // axis
7520 .channelQuant = {},
7521 .data = TestBuffer::createFromVector<int32_t>({-3}),
7522 .dimensions = {},
7523 .isIgnored = false,
7524 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7525 .numberOfConsumers = 1,
7526 .scale = 0.0f,
7527 .type = TestOperandType::INT32,
7528 .zeroPoint = 0
7529 }, { // op2
7530 .channelQuant = {},
7531 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7532 .dimensions = {2, 5, 2, 2},
7533 .isIgnored = false,
7534 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7535 .numberOfConsumers = 0,
7536 .scale = 0.0f,
7537 .type = TestOperandType::TENSOR_FLOAT32,
7538 .zeroPoint = 0
7539 }, { // op1_new
7540 .channelQuant = {},
7541 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
7542 .dimensions = {2, 5, 2, 2},
7543 .isIgnored = false,
7544 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7545 .numberOfConsumers = 1,
7546 .scale = 0.0f,
7547 .type = TestOperandType::TENSOR_FLOAT32,
7548 .zeroPoint = 0
7549 }, { // placeholder47
7550 .channelQuant = {},
7551 .data = TestBuffer::createFromVector<float>({0.0f}),
7552 .dimensions = {1},
7553 .isIgnored = false,
7554 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7555 .numberOfConsumers = 1,
7556 .scale = 0.0f,
7557 .type = TestOperandType::TENSOR_FLOAT32,
7558 .zeroPoint = 0
7559 }, { // param65
7560 .channelQuant = {},
7561 .data = TestBuffer::createFromVector<int32_t>({0}),
7562 .dimensions = {},
7563 .isIgnored = false,
7564 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7565 .numberOfConsumers = 1,
7566 .scale = 0.0f,
7567 .type = TestOperandType::INT32,
7568 .zeroPoint = 0
7569 }},
7570 .operations = {{
7571 .inputs = {4, 5, 6},
7572 .outputs = {0},
7573 .type = TestOperationType::ADD
7574 }, {
7575 .inputs = {0, 1, 2},
7576 .outputs = {3},
7577 .type = TestOperationType::SOFTMAX
7578 }},
7579 .outputIndexes = {3}
7580 },
7581 .minSupportedVersion = TestHalVersion::UNKNOWN,
7582 .referenced = {}
7583 };
7584 return model;
7585 }
7586
7587 const auto dummy_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal());
7588
7589 } // namespace generated_tests::softmax_v1_2
7590
7591 namespace generated_tests::softmax_v1_2 {
7592
get_test_model_axis_relaxed_dim4_axis2()7593 const TestModel& get_test_model_axis_relaxed_dim4_axis2() {
7594 static TestModel model = {
7595 .expectFailure = false,
7596 .expectedMultinomialDistributionTolerance = 0,
7597 .isRelaxed = true,
7598 .main = { // axis
7599 .inputIndexes = {0},
7600 .operands = {{ // op1
7601 .channelQuant = {},
7602 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
7603 .dimensions = {2, 2, 5, 2},
7604 .isIgnored = false,
7605 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7606 .numberOfConsumers = 1,
7607 .scale = 0.0f,
7608 .type = TestOperandType::TENSOR_FLOAT32,
7609 .zeroPoint = 0
7610 }, { // param2
7611 .channelQuant = {},
7612 .data = TestBuffer::createFromVector<float>({1.0f}),
7613 .dimensions = {},
7614 .isIgnored = false,
7615 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7616 .numberOfConsumers = 1,
7617 .scale = 0.0f,
7618 .type = TestOperandType::FLOAT32,
7619 .zeroPoint = 0
7620 }, { // axis
7621 .channelQuant = {},
7622 .data = TestBuffer::createFromVector<int32_t>({2}),
7623 .dimensions = {},
7624 .isIgnored = false,
7625 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7626 .numberOfConsumers = 1,
7627 .scale = 0.0f,
7628 .type = TestOperandType::INT32,
7629 .zeroPoint = 0
7630 }, { // op2
7631 .channelQuant = {},
7632 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7633 .dimensions = {2, 2, 5, 2},
7634 .isIgnored = false,
7635 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7636 .numberOfConsumers = 0,
7637 .scale = 0.0f,
7638 .type = TestOperandType::TENSOR_FLOAT32,
7639 .zeroPoint = 0
7640 }},
7641 .operations = {{
7642 .inputs = {0, 1, 2},
7643 .outputs = {3},
7644 .type = TestOperationType::SOFTMAX
7645 }},
7646 .outputIndexes = {3}
7647 },
7648 .minSupportedVersion = TestHalVersion::UNKNOWN,
7649 .referenced = {}
7650 };
7651 return model;
7652 }
7653
7654 const auto dummy_test_model_axis_relaxed_dim4_axis2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2", get_test_model_axis_relaxed_dim4_axis2());
7655
7656 } // namespace generated_tests::softmax_v1_2
7657
7658 namespace generated_tests::softmax_v1_2 {
7659
get_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal()7660 const TestModel& get_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal() {
7661 static TestModel model = {
7662 .expectFailure = false,
7663 .expectedMultinomialDistributionTolerance = 0,
7664 .isRelaxed = true,
7665 .main = { // axis
7666 .inputIndexes = {4},
7667 .operands = {{ // op1
7668 .channelQuant = {},
7669 .data = TestBuffer::createFromVector<float>({}),
7670 .dimensions = {2, 2, 5, 2},
7671 .isIgnored = false,
7672 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7673 .numberOfConsumers = 1,
7674 .scale = 0.0f,
7675 .type = TestOperandType::TENSOR_FLOAT32,
7676 .zeroPoint = 0
7677 }, { // param2
7678 .channelQuant = {},
7679 .data = TestBuffer::createFromVector<float>({1.0f}),
7680 .dimensions = {},
7681 .isIgnored = false,
7682 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7683 .numberOfConsumers = 1,
7684 .scale = 0.0f,
7685 .type = TestOperandType::FLOAT32,
7686 .zeroPoint = 0
7687 }, { // axis
7688 .channelQuant = {},
7689 .data = TestBuffer::createFromVector<int32_t>({2}),
7690 .dimensions = {},
7691 .isIgnored = false,
7692 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7693 .numberOfConsumers = 1,
7694 .scale = 0.0f,
7695 .type = TestOperandType::INT32,
7696 .zeroPoint = 0
7697 }, { // op2
7698 .channelQuant = {},
7699 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7700 .dimensions = {2, 2, 5, 2},
7701 .isIgnored = false,
7702 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7703 .numberOfConsumers = 0,
7704 .scale = 0.0f,
7705 .type = TestOperandType::TENSOR_FLOAT32,
7706 .zeroPoint = 0
7707 }, { // op1_new
7708 .channelQuant = {},
7709 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
7710 .dimensions = {2, 2, 5, 2},
7711 .isIgnored = false,
7712 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7713 .numberOfConsumers = 1,
7714 .scale = 0.0f,
7715 .type = TestOperandType::TENSOR_FLOAT32,
7716 .zeroPoint = 0
7717 }, { // placeholder48
7718 .channelQuant = {},
7719 .data = TestBuffer::createFromVector<float>({0.0f}),
7720 .dimensions = {1},
7721 .isIgnored = false,
7722 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7723 .numberOfConsumers = 1,
7724 .scale = 0.0f,
7725 .type = TestOperandType::TENSOR_FLOAT32,
7726 .zeroPoint = 0
7727 }, { // param66
7728 .channelQuant = {},
7729 .data = TestBuffer::createFromVector<int32_t>({0}),
7730 .dimensions = {},
7731 .isIgnored = false,
7732 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7733 .numberOfConsumers = 1,
7734 .scale = 0.0f,
7735 .type = TestOperandType::INT32,
7736 .zeroPoint = 0
7737 }},
7738 .operations = {{
7739 .inputs = {4, 5, 6},
7740 .outputs = {0},
7741 .type = TestOperationType::ADD
7742 }, {
7743 .inputs = {0, 1, 2},
7744 .outputs = {3},
7745 .type = TestOperationType::SOFTMAX
7746 }},
7747 .outputIndexes = {3}
7748 },
7749 .minSupportedVersion = TestHalVersion::UNKNOWN,
7750 .referenced = {}
7751 };
7752 return model;
7753 }
7754
7755 const auto dummy_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal());
7756
7757 } // namespace generated_tests::softmax_v1_2
7758
7759 namespace generated_tests::softmax_v1_2 {
7760
get_test_model_axis_relaxed_dim4_axis2_neg()7761 const TestModel& get_test_model_axis_relaxed_dim4_axis2_neg() {
7762 static TestModel model = {
7763 .expectFailure = false,
7764 .expectedMultinomialDistributionTolerance = 0,
7765 .isRelaxed = true,
7766 .main = { // axis
7767 .inputIndexes = {0},
7768 .operands = {{ // op1
7769 .channelQuant = {},
7770 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
7771 .dimensions = {2, 2, 5, 2},
7772 .isIgnored = false,
7773 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7774 .numberOfConsumers = 1,
7775 .scale = 0.0f,
7776 .type = TestOperandType::TENSOR_FLOAT32,
7777 .zeroPoint = 0
7778 }, { // param2
7779 .channelQuant = {},
7780 .data = TestBuffer::createFromVector<float>({1.0f}),
7781 .dimensions = {},
7782 .isIgnored = false,
7783 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7784 .numberOfConsumers = 1,
7785 .scale = 0.0f,
7786 .type = TestOperandType::FLOAT32,
7787 .zeroPoint = 0
7788 }, { // axis
7789 .channelQuant = {},
7790 .data = TestBuffer::createFromVector<int32_t>({-2}),
7791 .dimensions = {},
7792 .isIgnored = false,
7793 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7794 .numberOfConsumers = 1,
7795 .scale = 0.0f,
7796 .type = TestOperandType::INT32,
7797 .zeroPoint = 0
7798 }, { // op2
7799 .channelQuant = {},
7800 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7801 .dimensions = {2, 2, 5, 2},
7802 .isIgnored = false,
7803 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7804 .numberOfConsumers = 0,
7805 .scale = 0.0f,
7806 .type = TestOperandType::TENSOR_FLOAT32,
7807 .zeroPoint = 0
7808 }},
7809 .operations = {{
7810 .inputs = {0, 1, 2},
7811 .outputs = {3},
7812 .type = TestOperationType::SOFTMAX
7813 }},
7814 .outputIndexes = {3}
7815 },
7816 .minSupportedVersion = TestHalVersion::UNKNOWN,
7817 .referenced = {}
7818 };
7819 return model;
7820 }
7821
7822 const auto dummy_test_model_axis_relaxed_dim4_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2_neg", get_test_model_axis_relaxed_dim4_axis2_neg());
7823
7824 } // namespace generated_tests::softmax_v1_2
7825
7826 namespace generated_tests::softmax_v1_2 {
7827
get_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal()7828 const TestModel& get_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal() {
7829 static TestModel model = {
7830 .expectFailure = false,
7831 .expectedMultinomialDistributionTolerance = 0,
7832 .isRelaxed = true,
7833 .main = { // axis
7834 .inputIndexes = {4},
7835 .operands = {{ // op1
7836 .channelQuant = {},
7837 .data = TestBuffer::createFromVector<float>({}),
7838 .dimensions = {2, 2, 5, 2},
7839 .isIgnored = false,
7840 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7841 .numberOfConsumers = 1,
7842 .scale = 0.0f,
7843 .type = TestOperandType::TENSOR_FLOAT32,
7844 .zeroPoint = 0
7845 }, { // param2
7846 .channelQuant = {},
7847 .data = TestBuffer::createFromVector<float>({1.0f}),
7848 .dimensions = {},
7849 .isIgnored = false,
7850 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7851 .numberOfConsumers = 1,
7852 .scale = 0.0f,
7853 .type = TestOperandType::FLOAT32,
7854 .zeroPoint = 0
7855 }, { // axis
7856 .channelQuant = {},
7857 .data = TestBuffer::createFromVector<int32_t>({-2}),
7858 .dimensions = {},
7859 .isIgnored = false,
7860 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7861 .numberOfConsumers = 1,
7862 .scale = 0.0f,
7863 .type = TestOperandType::INT32,
7864 .zeroPoint = 0
7865 }, { // op2
7866 .channelQuant = {},
7867 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
7868 .dimensions = {2, 2, 5, 2},
7869 .isIgnored = false,
7870 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7871 .numberOfConsumers = 0,
7872 .scale = 0.0f,
7873 .type = TestOperandType::TENSOR_FLOAT32,
7874 .zeroPoint = 0
7875 }, { // op1_new
7876 .channelQuant = {},
7877 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
7878 .dimensions = {2, 2, 5, 2},
7879 .isIgnored = false,
7880 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7881 .numberOfConsumers = 1,
7882 .scale = 0.0f,
7883 .type = TestOperandType::TENSOR_FLOAT32,
7884 .zeroPoint = 0
7885 }, { // placeholder49
7886 .channelQuant = {},
7887 .data = TestBuffer::createFromVector<float>({0.0f}),
7888 .dimensions = {1},
7889 .isIgnored = false,
7890 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7891 .numberOfConsumers = 1,
7892 .scale = 0.0f,
7893 .type = TestOperandType::TENSOR_FLOAT32,
7894 .zeroPoint = 0
7895 }, { // param67
7896 .channelQuant = {},
7897 .data = TestBuffer::createFromVector<int32_t>({0}),
7898 .dimensions = {},
7899 .isIgnored = false,
7900 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7901 .numberOfConsumers = 1,
7902 .scale = 0.0f,
7903 .type = TestOperandType::INT32,
7904 .zeroPoint = 0
7905 }},
7906 .operations = {{
7907 .inputs = {4, 5, 6},
7908 .outputs = {0},
7909 .type = TestOperationType::ADD
7910 }, {
7911 .inputs = {0, 1, 2},
7912 .outputs = {3},
7913 .type = TestOperationType::SOFTMAX
7914 }},
7915 .outputIndexes = {3}
7916 },
7917 .minSupportedVersion = TestHalVersion::UNKNOWN,
7918 .referenced = {}
7919 };
7920 return model;
7921 }
7922
7923 const auto dummy_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal());
7924
7925 } // namespace generated_tests::softmax_v1_2
7926
7927 namespace generated_tests::softmax_v1_2 {
7928
get_test_model_axis_relaxed_dim4_axis3()7929 const TestModel& get_test_model_axis_relaxed_dim4_axis3() {
7930 static TestModel model = {
7931 .expectFailure = false,
7932 .expectedMultinomialDistributionTolerance = 0,
7933 .isRelaxed = true,
7934 .main = { // axis
7935 .inputIndexes = {0},
7936 .operands = {{ // op1
7937 .channelQuant = {},
7938 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
7939 .dimensions = {2, 2, 2, 5},
7940 .isIgnored = false,
7941 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7942 .numberOfConsumers = 1,
7943 .scale = 0.0f,
7944 .type = TestOperandType::TENSOR_FLOAT32,
7945 .zeroPoint = 0
7946 }, { // param2
7947 .channelQuant = {},
7948 .data = TestBuffer::createFromVector<float>({1.0f}),
7949 .dimensions = {},
7950 .isIgnored = false,
7951 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7952 .numberOfConsumers = 1,
7953 .scale = 0.0f,
7954 .type = TestOperandType::FLOAT32,
7955 .zeroPoint = 0
7956 }, { // axis
7957 .channelQuant = {},
7958 .data = TestBuffer::createFromVector<int32_t>({3}),
7959 .dimensions = {},
7960 .isIgnored = false,
7961 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7962 .numberOfConsumers = 1,
7963 .scale = 0.0f,
7964 .type = TestOperandType::INT32,
7965 .zeroPoint = 0
7966 }, { // op2
7967 .channelQuant = {},
7968 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
7969 .dimensions = {2, 2, 2, 5},
7970 .isIgnored = false,
7971 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7972 .numberOfConsumers = 0,
7973 .scale = 0.0f,
7974 .type = TestOperandType::TENSOR_FLOAT32,
7975 .zeroPoint = 0
7976 }},
7977 .operations = {{
7978 .inputs = {0, 1, 2},
7979 .outputs = {3},
7980 .type = TestOperationType::SOFTMAX
7981 }},
7982 .outputIndexes = {3}
7983 },
7984 .minSupportedVersion = TestHalVersion::UNKNOWN,
7985 .referenced = {}
7986 };
7987 return model;
7988 }
7989
7990 const auto dummy_test_model_axis_relaxed_dim4_axis3 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3", get_test_model_axis_relaxed_dim4_axis3());
7991
7992 } // namespace generated_tests::softmax_v1_2
7993
7994 namespace generated_tests::softmax_v1_2 {
7995
get_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal()7996 const TestModel& get_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal() {
7997 static TestModel model = {
7998 .expectFailure = false,
7999 .expectedMultinomialDistributionTolerance = 0,
8000 .isRelaxed = true,
8001 .main = { // axis
8002 .inputIndexes = {4},
8003 .operands = {{ // op1
8004 .channelQuant = {},
8005 .data = TestBuffer::createFromVector<float>({}),
8006 .dimensions = {2, 2, 2, 5},
8007 .isIgnored = false,
8008 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8009 .numberOfConsumers = 1,
8010 .scale = 0.0f,
8011 .type = TestOperandType::TENSOR_FLOAT32,
8012 .zeroPoint = 0
8013 }, { // param2
8014 .channelQuant = {},
8015 .data = TestBuffer::createFromVector<float>({1.0f}),
8016 .dimensions = {},
8017 .isIgnored = false,
8018 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8019 .numberOfConsumers = 1,
8020 .scale = 0.0f,
8021 .type = TestOperandType::FLOAT32,
8022 .zeroPoint = 0
8023 }, { // axis
8024 .channelQuant = {},
8025 .data = TestBuffer::createFromVector<int32_t>({3}),
8026 .dimensions = {},
8027 .isIgnored = false,
8028 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8029 .numberOfConsumers = 1,
8030 .scale = 0.0f,
8031 .type = TestOperandType::INT32,
8032 .zeroPoint = 0
8033 }, { // op2
8034 .channelQuant = {},
8035 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
8036 .dimensions = {2, 2, 2, 5},
8037 .isIgnored = false,
8038 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8039 .numberOfConsumers = 0,
8040 .scale = 0.0f,
8041 .type = TestOperandType::TENSOR_FLOAT32,
8042 .zeroPoint = 0
8043 }, { // op1_new
8044 .channelQuant = {},
8045 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
8046 .dimensions = {2, 2, 2, 5},
8047 .isIgnored = false,
8048 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8049 .numberOfConsumers = 1,
8050 .scale = 0.0f,
8051 .type = TestOperandType::TENSOR_FLOAT32,
8052 .zeroPoint = 0
8053 }, { // placeholder50
8054 .channelQuant = {},
8055 .data = TestBuffer::createFromVector<float>({0.0f}),
8056 .dimensions = {1},
8057 .isIgnored = false,
8058 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8059 .numberOfConsumers = 1,
8060 .scale = 0.0f,
8061 .type = TestOperandType::TENSOR_FLOAT32,
8062 .zeroPoint = 0
8063 }, { // param68
8064 .channelQuant = {},
8065 .data = TestBuffer::createFromVector<int32_t>({0}),
8066 .dimensions = {},
8067 .isIgnored = false,
8068 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8069 .numberOfConsumers = 1,
8070 .scale = 0.0f,
8071 .type = TestOperandType::INT32,
8072 .zeroPoint = 0
8073 }},
8074 .operations = {{
8075 .inputs = {4, 5, 6},
8076 .outputs = {0},
8077 .type = TestOperationType::ADD
8078 }, {
8079 .inputs = {0, 1, 2},
8080 .outputs = {3},
8081 .type = TestOperationType::SOFTMAX
8082 }},
8083 .outputIndexes = {3}
8084 },
8085 .minSupportedVersion = TestHalVersion::UNKNOWN,
8086 .referenced = {}
8087 };
8088 return model;
8089 }
8090
8091 const auto dummy_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal());
8092
8093 } // namespace generated_tests::softmax_v1_2
8094
8095 namespace generated_tests::softmax_v1_2 {
8096
get_test_model_axis_relaxed_dim4_axis3_neg()8097 const TestModel& get_test_model_axis_relaxed_dim4_axis3_neg() {
8098 static TestModel model = {
8099 .expectFailure = false,
8100 .expectedMultinomialDistributionTolerance = 0,
8101 .isRelaxed = true,
8102 .main = { // axis
8103 .inputIndexes = {0},
8104 .operands = {{ // op1
8105 .channelQuant = {},
8106 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
8107 .dimensions = {2, 2, 2, 5},
8108 .isIgnored = false,
8109 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8110 .numberOfConsumers = 1,
8111 .scale = 0.0f,
8112 .type = TestOperandType::TENSOR_FLOAT32,
8113 .zeroPoint = 0
8114 }, { // param2
8115 .channelQuant = {},
8116 .data = TestBuffer::createFromVector<float>({1.0f}),
8117 .dimensions = {},
8118 .isIgnored = false,
8119 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8120 .numberOfConsumers = 1,
8121 .scale = 0.0f,
8122 .type = TestOperandType::FLOAT32,
8123 .zeroPoint = 0
8124 }, { // axis
8125 .channelQuant = {},
8126 .data = TestBuffer::createFromVector<int32_t>({-1}),
8127 .dimensions = {},
8128 .isIgnored = false,
8129 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8130 .numberOfConsumers = 1,
8131 .scale = 0.0f,
8132 .type = TestOperandType::INT32,
8133 .zeroPoint = 0
8134 }, { // op2
8135 .channelQuant = {},
8136 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
8137 .dimensions = {2, 2, 2, 5},
8138 .isIgnored = false,
8139 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8140 .numberOfConsumers = 0,
8141 .scale = 0.0f,
8142 .type = TestOperandType::TENSOR_FLOAT32,
8143 .zeroPoint = 0
8144 }},
8145 .operations = {{
8146 .inputs = {0, 1, 2},
8147 .outputs = {3},
8148 .type = TestOperationType::SOFTMAX
8149 }},
8150 .outputIndexes = {3}
8151 },
8152 .minSupportedVersion = TestHalVersion::UNKNOWN,
8153 .referenced = {}
8154 };
8155 return model;
8156 }
8157
8158 const auto dummy_test_model_axis_relaxed_dim4_axis3_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3_neg", get_test_model_axis_relaxed_dim4_axis3_neg());
8159
8160 } // namespace generated_tests::softmax_v1_2
8161
8162 namespace generated_tests::softmax_v1_2 {
8163
get_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal()8164 const TestModel& get_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal() {
8165 static TestModel model = {
8166 .expectFailure = false,
8167 .expectedMultinomialDistributionTolerance = 0,
8168 .isRelaxed = true,
8169 .main = { // axis
8170 .inputIndexes = {4},
8171 .operands = {{ // op1
8172 .channelQuant = {},
8173 .data = TestBuffer::createFromVector<float>({}),
8174 .dimensions = {2, 2, 2, 5},
8175 .isIgnored = false,
8176 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8177 .numberOfConsumers = 1,
8178 .scale = 0.0f,
8179 .type = TestOperandType::TENSOR_FLOAT32,
8180 .zeroPoint = 0
8181 }, { // param2
8182 .channelQuant = {},
8183 .data = TestBuffer::createFromVector<float>({1.0f}),
8184 .dimensions = {},
8185 .isIgnored = false,
8186 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8187 .numberOfConsumers = 1,
8188 .scale = 0.0f,
8189 .type = TestOperandType::FLOAT32,
8190 .zeroPoint = 0
8191 }, { // axis
8192 .channelQuant = {},
8193 .data = TestBuffer::createFromVector<int32_t>({-1}),
8194 .dimensions = {},
8195 .isIgnored = false,
8196 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8197 .numberOfConsumers = 1,
8198 .scale = 0.0f,
8199 .type = TestOperandType::INT32,
8200 .zeroPoint = 0
8201 }, { // op2
8202 .channelQuant = {},
8203 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
8204 .dimensions = {2, 2, 2, 5},
8205 .isIgnored = false,
8206 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8207 .numberOfConsumers = 0,
8208 .scale = 0.0f,
8209 .type = TestOperandType::TENSOR_FLOAT32,
8210 .zeroPoint = 0
8211 }, { // op1_new
8212 .channelQuant = {},
8213 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
8214 .dimensions = {2, 2, 2, 5},
8215 .isIgnored = false,
8216 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8217 .numberOfConsumers = 1,
8218 .scale = 0.0f,
8219 .type = TestOperandType::TENSOR_FLOAT32,
8220 .zeroPoint = 0
8221 }, { // placeholder51
8222 .channelQuant = {},
8223 .data = TestBuffer::createFromVector<float>({0.0f}),
8224 .dimensions = {1},
8225 .isIgnored = false,
8226 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8227 .numberOfConsumers = 1,
8228 .scale = 0.0f,
8229 .type = TestOperandType::TENSOR_FLOAT32,
8230 .zeroPoint = 0
8231 }, { // param69
8232 .channelQuant = {},
8233 .data = TestBuffer::createFromVector<int32_t>({0}),
8234 .dimensions = {},
8235 .isIgnored = false,
8236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8237 .numberOfConsumers = 1,
8238 .scale = 0.0f,
8239 .type = TestOperandType::INT32,
8240 .zeroPoint = 0
8241 }},
8242 .operations = {{
8243 .inputs = {4, 5, 6},
8244 .outputs = {0},
8245 .type = TestOperationType::ADD
8246 }, {
8247 .inputs = {0, 1, 2},
8248 .outputs = {3},
8249 .type = TestOperationType::SOFTMAX
8250 }},
8251 .outputIndexes = {3}
8252 },
8253 .minSupportedVersion = TestHalVersion::UNKNOWN,
8254 .referenced = {}
8255 };
8256 return model;
8257 }
8258
8259 const auto dummy_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal());
8260
8261 } // namespace generated_tests::softmax_v1_2
8262
8263 namespace generated_tests::softmax_v1_2 {
8264
get_test_model_axis_relaxed_dim3_axis0()8265 const TestModel& get_test_model_axis_relaxed_dim3_axis0() {
8266 static TestModel model = {
8267 .expectFailure = false,
8268 .expectedMultinomialDistributionTolerance = 0,
8269 .isRelaxed = true,
8270 .main = { // axis
8271 .inputIndexes = {0},
8272 .operands = {{ // op1
8273 .channelQuant = {},
8274 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
8275 .dimensions = {5, 2, 2},
8276 .isIgnored = false,
8277 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8278 .numberOfConsumers = 1,
8279 .scale = 0.0f,
8280 .type = TestOperandType::TENSOR_FLOAT32,
8281 .zeroPoint = 0
8282 }, { // param2
8283 .channelQuant = {},
8284 .data = TestBuffer::createFromVector<float>({1.0f}),
8285 .dimensions = {},
8286 .isIgnored = false,
8287 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8288 .numberOfConsumers = 1,
8289 .scale = 0.0f,
8290 .type = TestOperandType::FLOAT32,
8291 .zeroPoint = 0
8292 }, { // axis
8293 .channelQuant = {},
8294 .data = TestBuffer::createFromVector<int32_t>({0}),
8295 .dimensions = {},
8296 .isIgnored = false,
8297 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8298 .numberOfConsumers = 1,
8299 .scale = 0.0f,
8300 .type = TestOperandType::INT32,
8301 .zeroPoint = 0
8302 }, { // op2
8303 .channelQuant = {},
8304 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8305 .dimensions = {5, 2, 2},
8306 .isIgnored = false,
8307 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8308 .numberOfConsumers = 0,
8309 .scale = 0.0f,
8310 .type = TestOperandType::TENSOR_FLOAT32,
8311 .zeroPoint = 0
8312 }},
8313 .operations = {{
8314 .inputs = {0, 1, 2},
8315 .outputs = {3},
8316 .type = TestOperationType::SOFTMAX
8317 }},
8318 .outputIndexes = {3}
8319 },
8320 .minSupportedVersion = TestHalVersion::UNKNOWN,
8321 .referenced = {}
8322 };
8323 return model;
8324 }
8325
8326 const auto dummy_test_model_axis_relaxed_dim3_axis0 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0", get_test_model_axis_relaxed_dim3_axis0());
8327
8328 } // namespace generated_tests::softmax_v1_2
8329
8330 namespace generated_tests::softmax_v1_2 {
8331
get_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal()8332 const TestModel& get_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal() {
8333 static TestModel model = {
8334 .expectFailure = false,
8335 .expectedMultinomialDistributionTolerance = 0,
8336 .isRelaxed = true,
8337 .main = { // axis
8338 .inputIndexes = {4},
8339 .operands = {{ // op1
8340 .channelQuant = {},
8341 .data = TestBuffer::createFromVector<float>({}),
8342 .dimensions = {5, 2, 2},
8343 .isIgnored = false,
8344 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8345 .numberOfConsumers = 1,
8346 .scale = 0.0f,
8347 .type = TestOperandType::TENSOR_FLOAT32,
8348 .zeroPoint = 0
8349 }, { // param2
8350 .channelQuant = {},
8351 .data = TestBuffer::createFromVector<float>({1.0f}),
8352 .dimensions = {},
8353 .isIgnored = false,
8354 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8355 .numberOfConsumers = 1,
8356 .scale = 0.0f,
8357 .type = TestOperandType::FLOAT32,
8358 .zeroPoint = 0
8359 }, { // axis
8360 .channelQuant = {},
8361 .data = TestBuffer::createFromVector<int32_t>({0}),
8362 .dimensions = {},
8363 .isIgnored = false,
8364 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8365 .numberOfConsumers = 1,
8366 .scale = 0.0f,
8367 .type = TestOperandType::INT32,
8368 .zeroPoint = 0
8369 }, { // op2
8370 .channelQuant = {},
8371 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8372 .dimensions = {5, 2, 2},
8373 .isIgnored = false,
8374 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8375 .numberOfConsumers = 0,
8376 .scale = 0.0f,
8377 .type = TestOperandType::TENSOR_FLOAT32,
8378 .zeroPoint = 0
8379 }, { // op1_new
8380 .channelQuant = {},
8381 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
8382 .dimensions = {5, 2, 2},
8383 .isIgnored = false,
8384 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8385 .numberOfConsumers = 1,
8386 .scale = 0.0f,
8387 .type = TestOperandType::TENSOR_FLOAT32,
8388 .zeroPoint = 0
8389 }, { // placeholder52
8390 .channelQuant = {},
8391 .data = TestBuffer::createFromVector<float>({0.0f}),
8392 .dimensions = {1},
8393 .isIgnored = false,
8394 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8395 .numberOfConsumers = 1,
8396 .scale = 0.0f,
8397 .type = TestOperandType::TENSOR_FLOAT32,
8398 .zeroPoint = 0
8399 }, { // param70
8400 .channelQuant = {},
8401 .data = TestBuffer::createFromVector<int32_t>({0}),
8402 .dimensions = {},
8403 .isIgnored = false,
8404 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8405 .numberOfConsumers = 1,
8406 .scale = 0.0f,
8407 .type = TestOperandType::INT32,
8408 .zeroPoint = 0
8409 }},
8410 .operations = {{
8411 .inputs = {4, 5, 6},
8412 .outputs = {0},
8413 .type = TestOperationType::ADD
8414 }, {
8415 .inputs = {0, 1, 2},
8416 .outputs = {3},
8417 .type = TestOperationType::SOFTMAX
8418 }},
8419 .outputIndexes = {3}
8420 },
8421 .minSupportedVersion = TestHalVersion::UNKNOWN,
8422 .referenced = {}
8423 };
8424 return model;
8425 }
8426
8427 const auto dummy_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0_all_inputs_as_internal", get_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal());
8428
8429 } // namespace generated_tests::softmax_v1_2
8430
8431 namespace generated_tests::softmax_v1_2 {
8432
get_test_model_axis_relaxed_dim3_axis0_neg()8433 const TestModel& get_test_model_axis_relaxed_dim3_axis0_neg() {
8434 static TestModel model = {
8435 .expectFailure = false,
8436 .expectedMultinomialDistributionTolerance = 0,
8437 .isRelaxed = true,
8438 .main = { // axis
8439 .inputIndexes = {0},
8440 .operands = {{ // op1
8441 .channelQuant = {},
8442 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
8443 .dimensions = {5, 2, 2},
8444 .isIgnored = false,
8445 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8446 .numberOfConsumers = 1,
8447 .scale = 0.0f,
8448 .type = TestOperandType::TENSOR_FLOAT32,
8449 .zeroPoint = 0
8450 }, { // param2
8451 .channelQuant = {},
8452 .data = TestBuffer::createFromVector<float>({1.0f}),
8453 .dimensions = {},
8454 .isIgnored = false,
8455 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8456 .numberOfConsumers = 1,
8457 .scale = 0.0f,
8458 .type = TestOperandType::FLOAT32,
8459 .zeroPoint = 0
8460 }, { // axis
8461 .channelQuant = {},
8462 .data = TestBuffer::createFromVector<int32_t>({-3}),
8463 .dimensions = {},
8464 .isIgnored = false,
8465 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8466 .numberOfConsumers = 1,
8467 .scale = 0.0f,
8468 .type = TestOperandType::INT32,
8469 .zeroPoint = 0
8470 }, { // op2
8471 .channelQuant = {},
8472 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8473 .dimensions = {5, 2, 2},
8474 .isIgnored = false,
8475 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8476 .numberOfConsumers = 0,
8477 .scale = 0.0f,
8478 .type = TestOperandType::TENSOR_FLOAT32,
8479 .zeroPoint = 0
8480 }},
8481 .operations = {{
8482 .inputs = {0, 1, 2},
8483 .outputs = {3},
8484 .type = TestOperationType::SOFTMAX
8485 }},
8486 .outputIndexes = {3}
8487 },
8488 .minSupportedVersion = TestHalVersion::UNKNOWN,
8489 .referenced = {}
8490 };
8491 return model;
8492 }
8493
8494 const auto dummy_test_model_axis_relaxed_dim3_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0_neg", get_test_model_axis_relaxed_dim3_axis0_neg());
8495
8496 } // namespace generated_tests::softmax_v1_2
8497
8498 namespace generated_tests::softmax_v1_2 {
8499
get_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal()8500 const TestModel& get_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal() {
8501 static TestModel model = {
8502 .expectFailure = false,
8503 .expectedMultinomialDistributionTolerance = 0,
8504 .isRelaxed = true,
8505 .main = { // axis
8506 .inputIndexes = {4},
8507 .operands = {{ // op1
8508 .channelQuant = {},
8509 .data = TestBuffer::createFromVector<float>({}),
8510 .dimensions = {5, 2, 2},
8511 .isIgnored = false,
8512 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8513 .numberOfConsumers = 1,
8514 .scale = 0.0f,
8515 .type = TestOperandType::TENSOR_FLOAT32,
8516 .zeroPoint = 0
8517 }, { // param2
8518 .channelQuant = {},
8519 .data = TestBuffer::createFromVector<float>({1.0f}),
8520 .dimensions = {},
8521 .isIgnored = false,
8522 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8523 .numberOfConsumers = 1,
8524 .scale = 0.0f,
8525 .type = TestOperandType::FLOAT32,
8526 .zeroPoint = 0
8527 }, { // axis
8528 .channelQuant = {},
8529 .data = TestBuffer::createFromVector<int32_t>({-3}),
8530 .dimensions = {},
8531 .isIgnored = false,
8532 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8533 .numberOfConsumers = 1,
8534 .scale = 0.0f,
8535 .type = TestOperandType::INT32,
8536 .zeroPoint = 0
8537 }, { // op2
8538 .channelQuant = {},
8539 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8540 .dimensions = {5, 2, 2},
8541 .isIgnored = false,
8542 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8543 .numberOfConsumers = 0,
8544 .scale = 0.0f,
8545 .type = TestOperandType::TENSOR_FLOAT32,
8546 .zeroPoint = 0
8547 }, { // op1_new
8548 .channelQuant = {},
8549 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
8550 .dimensions = {5, 2, 2},
8551 .isIgnored = false,
8552 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8553 .numberOfConsumers = 1,
8554 .scale = 0.0f,
8555 .type = TestOperandType::TENSOR_FLOAT32,
8556 .zeroPoint = 0
8557 }, { // placeholder53
8558 .channelQuant = {},
8559 .data = TestBuffer::createFromVector<float>({0.0f}),
8560 .dimensions = {1},
8561 .isIgnored = false,
8562 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8563 .numberOfConsumers = 1,
8564 .scale = 0.0f,
8565 .type = TestOperandType::TENSOR_FLOAT32,
8566 .zeroPoint = 0
8567 }, { // param71
8568 .channelQuant = {},
8569 .data = TestBuffer::createFromVector<int32_t>({0}),
8570 .dimensions = {},
8571 .isIgnored = false,
8572 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8573 .numberOfConsumers = 1,
8574 .scale = 0.0f,
8575 .type = TestOperandType::INT32,
8576 .zeroPoint = 0
8577 }},
8578 .operations = {{
8579 .inputs = {4, 5, 6},
8580 .outputs = {0},
8581 .type = TestOperationType::ADD
8582 }, {
8583 .inputs = {0, 1, 2},
8584 .outputs = {3},
8585 .type = TestOperationType::SOFTMAX
8586 }},
8587 .outputIndexes = {3}
8588 },
8589 .minSupportedVersion = TestHalVersion::UNKNOWN,
8590 .referenced = {}
8591 };
8592 return model;
8593 }
8594
8595 const auto dummy_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal());
8596
8597 } // namespace generated_tests::softmax_v1_2
8598
8599 namespace generated_tests::softmax_v1_2 {
8600
get_test_model_axis_relaxed_dim3_axis1()8601 const TestModel& get_test_model_axis_relaxed_dim3_axis1() {
8602 static TestModel model = {
8603 .expectFailure = false,
8604 .expectedMultinomialDistributionTolerance = 0,
8605 .isRelaxed = true,
8606 .main = { // axis
8607 .inputIndexes = {0},
8608 .operands = {{ // op1
8609 .channelQuant = {},
8610 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
8611 .dimensions = {2, 5, 2},
8612 .isIgnored = false,
8613 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8614 .numberOfConsumers = 1,
8615 .scale = 0.0f,
8616 .type = TestOperandType::TENSOR_FLOAT32,
8617 .zeroPoint = 0
8618 }, { // param2
8619 .channelQuant = {},
8620 .data = TestBuffer::createFromVector<float>({1.0f}),
8621 .dimensions = {},
8622 .isIgnored = false,
8623 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8624 .numberOfConsumers = 1,
8625 .scale = 0.0f,
8626 .type = TestOperandType::FLOAT32,
8627 .zeroPoint = 0
8628 }, { // axis
8629 .channelQuant = {},
8630 .data = TestBuffer::createFromVector<int32_t>({1}),
8631 .dimensions = {},
8632 .isIgnored = false,
8633 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8634 .numberOfConsumers = 1,
8635 .scale = 0.0f,
8636 .type = TestOperandType::INT32,
8637 .zeroPoint = 0
8638 }, { // op2
8639 .channelQuant = {},
8640 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8641 .dimensions = {2, 5, 2},
8642 .isIgnored = false,
8643 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8644 .numberOfConsumers = 0,
8645 .scale = 0.0f,
8646 .type = TestOperandType::TENSOR_FLOAT32,
8647 .zeroPoint = 0
8648 }},
8649 .operations = {{
8650 .inputs = {0, 1, 2},
8651 .outputs = {3},
8652 .type = TestOperationType::SOFTMAX
8653 }},
8654 .outputIndexes = {3}
8655 },
8656 .minSupportedVersion = TestHalVersion::UNKNOWN,
8657 .referenced = {}
8658 };
8659 return model;
8660 }
8661
8662 const auto dummy_test_model_axis_relaxed_dim3_axis1 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1", get_test_model_axis_relaxed_dim3_axis1());
8663
8664 } // namespace generated_tests::softmax_v1_2
8665
8666 namespace generated_tests::softmax_v1_2 {
8667
get_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal()8668 const TestModel& get_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal() {
8669 static TestModel model = {
8670 .expectFailure = false,
8671 .expectedMultinomialDistributionTolerance = 0,
8672 .isRelaxed = true,
8673 .main = { // axis
8674 .inputIndexes = {4},
8675 .operands = {{ // op1
8676 .channelQuant = {},
8677 .data = TestBuffer::createFromVector<float>({}),
8678 .dimensions = {2, 5, 2},
8679 .isIgnored = false,
8680 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8681 .numberOfConsumers = 1,
8682 .scale = 0.0f,
8683 .type = TestOperandType::TENSOR_FLOAT32,
8684 .zeroPoint = 0
8685 }, { // param2
8686 .channelQuant = {},
8687 .data = TestBuffer::createFromVector<float>({1.0f}),
8688 .dimensions = {},
8689 .isIgnored = false,
8690 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8691 .numberOfConsumers = 1,
8692 .scale = 0.0f,
8693 .type = TestOperandType::FLOAT32,
8694 .zeroPoint = 0
8695 }, { // axis
8696 .channelQuant = {},
8697 .data = TestBuffer::createFromVector<int32_t>({1}),
8698 .dimensions = {},
8699 .isIgnored = false,
8700 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8701 .numberOfConsumers = 1,
8702 .scale = 0.0f,
8703 .type = TestOperandType::INT32,
8704 .zeroPoint = 0
8705 }, { // op2
8706 .channelQuant = {},
8707 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8708 .dimensions = {2, 5, 2},
8709 .isIgnored = false,
8710 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8711 .numberOfConsumers = 0,
8712 .scale = 0.0f,
8713 .type = TestOperandType::TENSOR_FLOAT32,
8714 .zeroPoint = 0
8715 }, { // op1_new
8716 .channelQuant = {},
8717 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
8718 .dimensions = {2, 5, 2},
8719 .isIgnored = false,
8720 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8721 .numberOfConsumers = 1,
8722 .scale = 0.0f,
8723 .type = TestOperandType::TENSOR_FLOAT32,
8724 .zeroPoint = 0
8725 }, { // placeholder54
8726 .channelQuant = {},
8727 .data = TestBuffer::createFromVector<float>({0.0f}),
8728 .dimensions = {1},
8729 .isIgnored = false,
8730 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8731 .numberOfConsumers = 1,
8732 .scale = 0.0f,
8733 .type = TestOperandType::TENSOR_FLOAT32,
8734 .zeroPoint = 0
8735 }, { // param72
8736 .channelQuant = {},
8737 .data = TestBuffer::createFromVector<int32_t>({0}),
8738 .dimensions = {},
8739 .isIgnored = false,
8740 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8741 .numberOfConsumers = 1,
8742 .scale = 0.0f,
8743 .type = TestOperandType::INT32,
8744 .zeroPoint = 0
8745 }},
8746 .operations = {{
8747 .inputs = {4, 5, 6},
8748 .outputs = {0},
8749 .type = TestOperationType::ADD
8750 }, {
8751 .inputs = {0, 1, 2},
8752 .outputs = {3},
8753 .type = TestOperationType::SOFTMAX
8754 }},
8755 .outputIndexes = {3}
8756 },
8757 .minSupportedVersion = TestHalVersion::UNKNOWN,
8758 .referenced = {}
8759 };
8760 return model;
8761 }
8762
8763 const auto dummy_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1_all_inputs_as_internal", get_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal());
8764
8765 } // namespace generated_tests::softmax_v1_2
8766
8767 namespace generated_tests::softmax_v1_2 {
8768
get_test_model_axis_relaxed_dim3_axis1_neg()8769 const TestModel& get_test_model_axis_relaxed_dim3_axis1_neg() {
8770 static TestModel model = {
8771 .expectFailure = false,
8772 .expectedMultinomialDistributionTolerance = 0,
8773 .isRelaxed = true,
8774 .main = { // axis
8775 .inputIndexes = {0},
8776 .operands = {{ // op1
8777 .channelQuant = {},
8778 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
8779 .dimensions = {2, 5, 2},
8780 .isIgnored = false,
8781 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8782 .numberOfConsumers = 1,
8783 .scale = 0.0f,
8784 .type = TestOperandType::TENSOR_FLOAT32,
8785 .zeroPoint = 0
8786 }, { // param2
8787 .channelQuant = {},
8788 .data = TestBuffer::createFromVector<float>({1.0f}),
8789 .dimensions = {},
8790 .isIgnored = false,
8791 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8792 .numberOfConsumers = 1,
8793 .scale = 0.0f,
8794 .type = TestOperandType::FLOAT32,
8795 .zeroPoint = 0
8796 }, { // axis
8797 .channelQuant = {},
8798 .data = TestBuffer::createFromVector<int32_t>({-2}),
8799 .dimensions = {},
8800 .isIgnored = false,
8801 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8802 .numberOfConsumers = 1,
8803 .scale = 0.0f,
8804 .type = TestOperandType::INT32,
8805 .zeroPoint = 0
8806 }, { // op2
8807 .channelQuant = {},
8808 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8809 .dimensions = {2, 5, 2},
8810 .isIgnored = false,
8811 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8812 .numberOfConsumers = 0,
8813 .scale = 0.0f,
8814 .type = TestOperandType::TENSOR_FLOAT32,
8815 .zeroPoint = 0
8816 }},
8817 .operations = {{
8818 .inputs = {0, 1, 2},
8819 .outputs = {3},
8820 .type = TestOperationType::SOFTMAX
8821 }},
8822 .outputIndexes = {3}
8823 },
8824 .minSupportedVersion = TestHalVersion::UNKNOWN,
8825 .referenced = {}
8826 };
8827 return model;
8828 }
8829
8830 const auto dummy_test_model_axis_relaxed_dim3_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1_neg", get_test_model_axis_relaxed_dim3_axis1_neg());
8831
8832 } // namespace generated_tests::softmax_v1_2
8833
8834 namespace generated_tests::softmax_v1_2 {
8835
get_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal()8836 const TestModel& get_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal() {
8837 static TestModel model = {
8838 .expectFailure = false,
8839 .expectedMultinomialDistributionTolerance = 0,
8840 .isRelaxed = true,
8841 .main = { // axis
8842 .inputIndexes = {4},
8843 .operands = {{ // op1
8844 .channelQuant = {},
8845 .data = TestBuffer::createFromVector<float>({}),
8846 .dimensions = {2, 5, 2},
8847 .isIgnored = false,
8848 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8849 .numberOfConsumers = 1,
8850 .scale = 0.0f,
8851 .type = TestOperandType::TENSOR_FLOAT32,
8852 .zeroPoint = 0
8853 }, { // param2
8854 .channelQuant = {},
8855 .data = TestBuffer::createFromVector<float>({1.0f}),
8856 .dimensions = {},
8857 .isIgnored = false,
8858 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8859 .numberOfConsumers = 1,
8860 .scale = 0.0f,
8861 .type = TestOperandType::FLOAT32,
8862 .zeroPoint = 0
8863 }, { // axis
8864 .channelQuant = {},
8865 .data = TestBuffer::createFromVector<int32_t>({-2}),
8866 .dimensions = {},
8867 .isIgnored = false,
8868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8869 .numberOfConsumers = 1,
8870 .scale = 0.0f,
8871 .type = TestOperandType::INT32,
8872 .zeroPoint = 0
8873 }, { // op2
8874 .channelQuant = {},
8875 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f, 0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
8876 .dimensions = {2, 5, 2},
8877 .isIgnored = false,
8878 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8879 .numberOfConsumers = 0,
8880 .scale = 0.0f,
8881 .type = TestOperandType::TENSOR_FLOAT32,
8882 .zeroPoint = 0
8883 }, { // op1_new
8884 .channelQuant = {},
8885 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
8886 .dimensions = {2, 5, 2},
8887 .isIgnored = false,
8888 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8889 .numberOfConsumers = 1,
8890 .scale = 0.0f,
8891 .type = TestOperandType::TENSOR_FLOAT32,
8892 .zeroPoint = 0
8893 }, { // placeholder55
8894 .channelQuant = {},
8895 .data = TestBuffer::createFromVector<float>({0.0f}),
8896 .dimensions = {1},
8897 .isIgnored = false,
8898 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8899 .numberOfConsumers = 1,
8900 .scale = 0.0f,
8901 .type = TestOperandType::TENSOR_FLOAT32,
8902 .zeroPoint = 0
8903 }, { // param73
8904 .channelQuant = {},
8905 .data = TestBuffer::createFromVector<int32_t>({0}),
8906 .dimensions = {},
8907 .isIgnored = false,
8908 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8909 .numberOfConsumers = 1,
8910 .scale = 0.0f,
8911 .type = TestOperandType::INT32,
8912 .zeroPoint = 0
8913 }},
8914 .operations = {{
8915 .inputs = {4, 5, 6},
8916 .outputs = {0},
8917 .type = TestOperationType::ADD
8918 }, {
8919 .inputs = {0, 1, 2},
8920 .outputs = {3},
8921 .type = TestOperationType::SOFTMAX
8922 }},
8923 .outputIndexes = {3}
8924 },
8925 .minSupportedVersion = TestHalVersion::UNKNOWN,
8926 .referenced = {}
8927 };
8928 return model;
8929 }
8930
8931 const auto dummy_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal());
8932
8933 } // namespace generated_tests::softmax_v1_2
8934
8935 namespace generated_tests::softmax_v1_2 {
8936
get_test_model_axis_relaxed_dim3_axis2()8937 const TestModel& get_test_model_axis_relaxed_dim3_axis2() {
8938 static TestModel model = {
8939 .expectFailure = false,
8940 .expectedMultinomialDistributionTolerance = 0,
8941 .isRelaxed = true,
8942 .main = { // axis
8943 .inputIndexes = {0},
8944 .operands = {{ // op1
8945 .channelQuant = {},
8946 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
8947 .dimensions = {2, 2, 5},
8948 .isIgnored = false,
8949 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8950 .numberOfConsumers = 1,
8951 .scale = 0.0f,
8952 .type = TestOperandType::TENSOR_FLOAT32,
8953 .zeroPoint = 0
8954 }, { // param2
8955 .channelQuant = {},
8956 .data = TestBuffer::createFromVector<float>({1.0f}),
8957 .dimensions = {},
8958 .isIgnored = false,
8959 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8960 .numberOfConsumers = 1,
8961 .scale = 0.0f,
8962 .type = TestOperandType::FLOAT32,
8963 .zeroPoint = 0
8964 }, { // axis
8965 .channelQuant = {},
8966 .data = TestBuffer::createFromVector<int32_t>({2}),
8967 .dimensions = {},
8968 .isIgnored = false,
8969 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8970 .numberOfConsumers = 1,
8971 .scale = 0.0f,
8972 .type = TestOperandType::INT32,
8973 .zeroPoint = 0
8974 }, { // op2
8975 .channelQuant = {},
8976 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
8977 .dimensions = {2, 2, 5},
8978 .isIgnored = false,
8979 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8980 .numberOfConsumers = 0,
8981 .scale = 0.0f,
8982 .type = TestOperandType::TENSOR_FLOAT32,
8983 .zeroPoint = 0
8984 }},
8985 .operations = {{
8986 .inputs = {0, 1, 2},
8987 .outputs = {3},
8988 .type = TestOperationType::SOFTMAX
8989 }},
8990 .outputIndexes = {3}
8991 },
8992 .minSupportedVersion = TestHalVersion::UNKNOWN,
8993 .referenced = {}
8994 };
8995 return model;
8996 }
8997
8998 const auto dummy_test_model_axis_relaxed_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2", get_test_model_axis_relaxed_dim3_axis2());
8999
9000 } // namespace generated_tests::softmax_v1_2
9001
9002 namespace generated_tests::softmax_v1_2 {
9003
get_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal()9004 const TestModel& get_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal() {
9005 static TestModel model = {
9006 .expectFailure = false,
9007 .expectedMultinomialDistributionTolerance = 0,
9008 .isRelaxed = true,
9009 .main = { // axis
9010 .inputIndexes = {4},
9011 .operands = {{ // op1
9012 .channelQuant = {},
9013 .data = TestBuffer::createFromVector<float>({}),
9014 .dimensions = {2, 2, 5},
9015 .isIgnored = false,
9016 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9017 .numberOfConsumers = 1,
9018 .scale = 0.0f,
9019 .type = TestOperandType::TENSOR_FLOAT32,
9020 .zeroPoint = 0
9021 }, { // param2
9022 .channelQuant = {},
9023 .data = TestBuffer::createFromVector<float>({1.0f}),
9024 .dimensions = {},
9025 .isIgnored = false,
9026 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9027 .numberOfConsumers = 1,
9028 .scale = 0.0f,
9029 .type = TestOperandType::FLOAT32,
9030 .zeroPoint = 0
9031 }, { // axis
9032 .channelQuant = {},
9033 .data = TestBuffer::createFromVector<int32_t>({2}),
9034 .dimensions = {},
9035 .isIgnored = false,
9036 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9037 .numberOfConsumers = 1,
9038 .scale = 0.0f,
9039 .type = TestOperandType::INT32,
9040 .zeroPoint = 0
9041 }, { // op2
9042 .channelQuant = {},
9043 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9044 .dimensions = {2, 2, 5},
9045 .isIgnored = false,
9046 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9047 .numberOfConsumers = 0,
9048 .scale = 0.0f,
9049 .type = TestOperandType::TENSOR_FLOAT32,
9050 .zeroPoint = 0
9051 }, { // op1_new
9052 .channelQuant = {},
9053 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
9054 .dimensions = {2, 2, 5},
9055 .isIgnored = false,
9056 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9057 .numberOfConsumers = 1,
9058 .scale = 0.0f,
9059 .type = TestOperandType::TENSOR_FLOAT32,
9060 .zeroPoint = 0
9061 }, { // placeholder56
9062 .channelQuant = {},
9063 .data = TestBuffer::createFromVector<float>({0.0f}),
9064 .dimensions = {1},
9065 .isIgnored = false,
9066 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9067 .numberOfConsumers = 1,
9068 .scale = 0.0f,
9069 .type = TestOperandType::TENSOR_FLOAT32,
9070 .zeroPoint = 0
9071 }, { // param74
9072 .channelQuant = {},
9073 .data = TestBuffer::createFromVector<int32_t>({0}),
9074 .dimensions = {},
9075 .isIgnored = false,
9076 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9077 .numberOfConsumers = 1,
9078 .scale = 0.0f,
9079 .type = TestOperandType::INT32,
9080 .zeroPoint = 0
9081 }},
9082 .operations = {{
9083 .inputs = {4, 5, 6},
9084 .outputs = {0},
9085 .type = TestOperationType::ADD
9086 }, {
9087 .inputs = {0, 1, 2},
9088 .outputs = {3},
9089 .type = TestOperationType::SOFTMAX
9090 }},
9091 .outputIndexes = {3}
9092 },
9093 .minSupportedVersion = TestHalVersion::UNKNOWN,
9094 .referenced = {}
9095 };
9096 return model;
9097 }
9098
9099 const auto dummy_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2_all_inputs_as_internal", get_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal());
9100
9101 } // namespace generated_tests::softmax_v1_2
9102
9103 namespace generated_tests::softmax_v1_2 {
9104
get_test_model_axis_relaxed_dim3_axis2_neg()9105 const TestModel& get_test_model_axis_relaxed_dim3_axis2_neg() {
9106 static TestModel model = {
9107 .expectFailure = false,
9108 .expectedMultinomialDistributionTolerance = 0,
9109 .isRelaxed = true,
9110 .main = { // axis
9111 .inputIndexes = {0},
9112 .operands = {{ // op1
9113 .channelQuant = {},
9114 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
9115 .dimensions = {2, 2, 5},
9116 .isIgnored = false,
9117 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9118 .numberOfConsumers = 1,
9119 .scale = 0.0f,
9120 .type = TestOperandType::TENSOR_FLOAT32,
9121 .zeroPoint = 0
9122 }, { // param2
9123 .channelQuant = {},
9124 .data = TestBuffer::createFromVector<float>({1.0f}),
9125 .dimensions = {},
9126 .isIgnored = false,
9127 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9128 .numberOfConsumers = 1,
9129 .scale = 0.0f,
9130 .type = TestOperandType::FLOAT32,
9131 .zeroPoint = 0
9132 }, { // axis
9133 .channelQuant = {},
9134 .data = TestBuffer::createFromVector<int32_t>({-1}),
9135 .dimensions = {},
9136 .isIgnored = false,
9137 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9138 .numberOfConsumers = 1,
9139 .scale = 0.0f,
9140 .type = TestOperandType::INT32,
9141 .zeroPoint = 0
9142 }, { // op2
9143 .channelQuant = {},
9144 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9145 .dimensions = {2, 2, 5},
9146 .isIgnored = false,
9147 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9148 .numberOfConsumers = 0,
9149 .scale = 0.0f,
9150 .type = TestOperandType::TENSOR_FLOAT32,
9151 .zeroPoint = 0
9152 }},
9153 .operations = {{
9154 .inputs = {0, 1, 2},
9155 .outputs = {3},
9156 .type = TestOperationType::SOFTMAX
9157 }},
9158 .outputIndexes = {3}
9159 },
9160 .minSupportedVersion = TestHalVersion::UNKNOWN,
9161 .referenced = {}
9162 };
9163 return model;
9164 }
9165
9166 const auto dummy_test_model_axis_relaxed_dim3_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2_neg", get_test_model_axis_relaxed_dim3_axis2_neg());
9167
9168 } // namespace generated_tests::softmax_v1_2
9169
9170 namespace generated_tests::softmax_v1_2 {
9171
get_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal()9172 const TestModel& get_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal() {
9173 static TestModel model = {
9174 .expectFailure = false,
9175 .expectedMultinomialDistributionTolerance = 0,
9176 .isRelaxed = true,
9177 .main = { // axis
9178 .inputIndexes = {4},
9179 .operands = {{ // op1
9180 .channelQuant = {},
9181 .data = TestBuffer::createFromVector<float>({}),
9182 .dimensions = {2, 2, 5},
9183 .isIgnored = false,
9184 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9185 .numberOfConsumers = 1,
9186 .scale = 0.0f,
9187 .type = TestOperandType::TENSOR_FLOAT32,
9188 .zeroPoint = 0
9189 }, { // param2
9190 .channelQuant = {},
9191 .data = TestBuffer::createFromVector<float>({1.0f}),
9192 .dimensions = {},
9193 .isIgnored = false,
9194 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9195 .numberOfConsumers = 1,
9196 .scale = 0.0f,
9197 .type = TestOperandType::FLOAT32,
9198 .zeroPoint = 0
9199 }, { // axis
9200 .channelQuant = {},
9201 .data = TestBuffer::createFromVector<int32_t>({-1}),
9202 .dimensions = {},
9203 .isIgnored = false,
9204 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9205 .numberOfConsumers = 1,
9206 .scale = 0.0f,
9207 .type = TestOperandType::INT32,
9208 .zeroPoint = 0
9209 }, { // op2
9210 .channelQuant = {},
9211 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9212 .dimensions = {2, 2, 5},
9213 .isIgnored = false,
9214 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9215 .numberOfConsumers = 0,
9216 .scale = 0.0f,
9217 .type = TestOperandType::TENSOR_FLOAT32,
9218 .zeroPoint = 0
9219 }, { // op1_new
9220 .channelQuant = {},
9221 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
9222 .dimensions = {2, 2, 5},
9223 .isIgnored = false,
9224 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9225 .numberOfConsumers = 1,
9226 .scale = 0.0f,
9227 .type = TestOperandType::TENSOR_FLOAT32,
9228 .zeroPoint = 0
9229 }, { // placeholder57
9230 .channelQuant = {},
9231 .data = TestBuffer::createFromVector<float>({0.0f}),
9232 .dimensions = {1},
9233 .isIgnored = false,
9234 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9235 .numberOfConsumers = 1,
9236 .scale = 0.0f,
9237 .type = TestOperandType::TENSOR_FLOAT32,
9238 .zeroPoint = 0
9239 }, { // param75
9240 .channelQuant = {},
9241 .data = TestBuffer::createFromVector<int32_t>({0}),
9242 .dimensions = {},
9243 .isIgnored = false,
9244 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9245 .numberOfConsumers = 1,
9246 .scale = 0.0f,
9247 .type = TestOperandType::INT32,
9248 .zeroPoint = 0
9249 }},
9250 .operations = {{
9251 .inputs = {4, 5, 6},
9252 .outputs = {0},
9253 .type = TestOperationType::ADD
9254 }, {
9255 .inputs = {0, 1, 2},
9256 .outputs = {3},
9257 .type = TestOperationType::SOFTMAX
9258 }},
9259 .outputIndexes = {3}
9260 },
9261 .minSupportedVersion = TestHalVersion::UNKNOWN,
9262 .referenced = {}
9263 };
9264 return model;
9265 }
9266
9267 const auto dummy_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal());
9268
9269 } // namespace generated_tests::softmax_v1_2
9270
9271 namespace generated_tests::softmax_v1_2 {
9272
get_test_model_axis_relaxed_dim2_axis0()9273 const TestModel& get_test_model_axis_relaxed_dim2_axis0() {
9274 static TestModel model = {
9275 .expectFailure = false,
9276 .expectedMultinomialDistributionTolerance = 0,
9277 .isRelaxed = true,
9278 .main = { // axis
9279 .inputIndexes = {0},
9280 .operands = {{ // op1
9281 .channelQuant = {},
9282 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
9283 .dimensions = {5, 2},
9284 .isIgnored = false,
9285 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9286 .numberOfConsumers = 1,
9287 .scale = 0.0f,
9288 .type = TestOperandType::TENSOR_FLOAT32,
9289 .zeroPoint = 0
9290 }, { // param2
9291 .channelQuant = {},
9292 .data = TestBuffer::createFromVector<float>({1.0f}),
9293 .dimensions = {},
9294 .isIgnored = false,
9295 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9296 .numberOfConsumers = 1,
9297 .scale = 0.0f,
9298 .type = TestOperandType::FLOAT32,
9299 .zeroPoint = 0
9300 }, { // axis
9301 .channelQuant = {},
9302 .data = TestBuffer::createFromVector<int32_t>({0}),
9303 .dimensions = {},
9304 .isIgnored = false,
9305 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9306 .numberOfConsumers = 1,
9307 .scale = 0.0f,
9308 .type = TestOperandType::INT32,
9309 .zeroPoint = 0
9310 }, { // op2
9311 .channelQuant = {},
9312 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
9313 .dimensions = {5, 2},
9314 .isIgnored = false,
9315 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9316 .numberOfConsumers = 0,
9317 .scale = 0.0f,
9318 .type = TestOperandType::TENSOR_FLOAT32,
9319 .zeroPoint = 0
9320 }},
9321 .operations = {{
9322 .inputs = {0, 1, 2},
9323 .outputs = {3},
9324 .type = TestOperationType::SOFTMAX
9325 }},
9326 .outputIndexes = {3}
9327 },
9328 .minSupportedVersion = TestHalVersion::UNKNOWN,
9329 .referenced = {}
9330 };
9331 return model;
9332 }
9333
9334 const auto dummy_test_model_axis_relaxed_dim2_axis0 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0", get_test_model_axis_relaxed_dim2_axis0());
9335
9336 } // namespace generated_tests::softmax_v1_2
9337
9338 namespace generated_tests::softmax_v1_2 {
9339
get_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal()9340 const TestModel& get_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal() {
9341 static TestModel model = {
9342 .expectFailure = false,
9343 .expectedMultinomialDistributionTolerance = 0,
9344 .isRelaxed = true,
9345 .main = { // axis
9346 .inputIndexes = {4},
9347 .operands = {{ // op1
9348 .channelQuant = {},
9349 .data = TestBuffer::createFromVector<float>({}),
9350 .dimensions = {5, 2},
9351 .isIgnored = false,
9352 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9353 .numberOfConsumers = 1,
9354 .scale = 0.0f,
9355 .type = TestOperandType::TENSOR_FLOAT32,
9356 .zeroPoint = 0
9357 }, { // param2
9358 .channelQuant = {},
9359 .data = TestBuffer::createFromVector<float>({1.0f}),
9360 .dimensions = {},
9361 .isIgnored = false,
9362 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9363 .numberOfConsumers = 1,
9364 .scale = 0.0f,
9365 .type = TestOperandType::FLOAT32,
9366 .zeroPoint = 0
9367 }, { // axis
9368 .channelQuant = {},
9369 .data = TestBuffer::createFromVector<int32_t>({0}),
9370 .dimensions = {},
9371 .isIgnored = false,
9372 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9373 .numberOfConsumers = 1,
9374 .scale = 0.0f,
9375 .type = TestOperandType::INT32,
9376 .zeroPoint = 0
9377 }, { // op2
9378 .channelQuant = {},
9379 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
9380 .dimensions = {5, 2},
9381 .isIgnored = false,
9382 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9383 .numberOfConsumers = 0,
9384 .scale = 0.0f,
9385 .type = TestOperandType::TENSOR_FLOAT32,
9386 .zeroPoint = 0
9387 }, { // op1_new
9388 .channelQuant = {},
9389 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
9390 .dimensions = {5, 2},
9391 .isIgnored = false,
9392 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9393 .numberOfConsumers = 1,
9394 .scale = 0.0f,
9395 .type = TestOperandType::TENSOR_FLOAT32,
9396 .zeroPoint = 0
9397 }, { // placeholder58
9398 .channelQuant = {},
9399 .data = TestBuffer::createFromVector<float>({0.0f}),
9400 .dimensions = {1},
9401 .isIgnored = false,
9402 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9403 .numberOfConsumers = 1,
9404 .scale = 0.0f,
9405 .type = TestOperandType::TENSOR_FLOAT32,
9406 .zeroPoint = 0
9407 }, { // param76
9408 .channelQuant = {},
9409 .data = TestBuffer::createFromVector<int32_t>({0}),
9410 .dimensions = {},
9411 .isIgnored = false,
9412 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9413 .numberOfConsumers = 1,
9414 .scale = 0.0f,
9415 .type = TestOperandType::INT32,
9416 .zeroPoint = 0
9417 }},
9418 .operations = {{
9419 .inputs = {4, 5, 6},
9420 .outputs = {0},
9421 .type = TestOperationType::ADD
9422 }, {
9423 .inputs = {0, 1, 2},
9424 .outputs = {3},
9425 .type = TestOperationType::SOFTMAX
9426 }},
9427 .outputIndexes = {3}
9428 },
9429 .minSupportedVersion = TestHalVersion::UNKNOWN,
9430 .referenced = {}
9431 };
9432 return model;
9433 }
9434
9435 const auto dummy_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0_all_inputs_as_internal", get_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal());
9436
9437 } // namespace generated_tests::softmax_v1_2
9438
9439 namespace generated_tests::softmax_v1_2 {
9440
get_test_model_axis_relaxed_dim2_axis0_neg()9441 const TestModel& get_test_model_axis_relaxed_dim2_axis0_neg() {
9442 static TestModel model = {
9443 .expectFailure = false,
9444 .expectedMultinomialDistributionTolerance = 0,
9445 .isRelaxed = true,
9446 .main = { // axis
9447 .inputIndexes = {0},
9448 .operands = {{ // op1
9449 .channelQuant = {},
9450 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
9451 .dimensions = {5, 2},
9452 .isIgnored = false,
9453 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9454 .numberOfConsumers = 1,
9455 .scale = 0.0f,
9456 .type = TestOperandType::TENSOR_FLOAT32,
9457 .zeroPoint = 0
9458 }, { // param2
9459 .channelQuant = {},
9460 .data = TestBuffer::createFromVector<float>({1.0f}),
9461 .dimensions = {},
9462 .isIgnored = false,
9463 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9464 .numberOfConsumers = 1,
9465 .scale = 0.0f,
9466 .type = TestOperandType::FLOAT32,
9467 .zeroPoint = 0
9468 }, { // axis
9469 .channelQuant = {},
9470 .data = TestBuffer::createFromVector<int32_t>({-2}),
9471 .dimensions = {},
9472 .isIgnored = false,
9473 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9474 .numberOfConsumers = 1,
9475 .scale = 0.0f,
9476 .type = TestOperandType::INT32,
9477 .zeroPoint = 0
9478 }, { // op2
9479 .channelQuant = {},
9480 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
9481 .dimensions = {5, 2},
9482 .isIgnored = false,
9483 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9484 .numberOfConsumers = 0,
9485 .scale = 0.0f,
9486 .type = TestOperandType::TENSOR_FLOAT32,
9487 .zeroPoint = 0
9488 }},
9489 .operations = {{
9490 .inputs = {0, 1, 2},
9491 .outputs = {3},
9492 .type = TestOperationType::SOFTMAX
9493 }},
9494 .outputIndexes = {3}
9495 },
9496 .minSupportedVersion = TestHalVersion::UNKNOWN,
9497 .referenced = {}
9498 };
9499 return model;
9500 }
9501
9502 const auto dummy_test_model_axis_relaxed_dim2_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0_neg", get_test_model_axis_relaxed_dim2_axis0_neg());
9503
9504 } // namespace generated_tests::softmax_v1_2
9505
9506 namespace generated_tests::softmax_v1_2 {
9507
get_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal()9508 const TestModel& get_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal() {
9509 static TestModel model = {
9510 .expectFailure = false,
9511 .expectedMultinomialDistributionTolerance = 0,
9512 .isRelaxed = true,
9513 .main = { // axis
9514 .inputIndexes = {4},
9515 .operands = {{ // op1
9516 .channelQuant = {},
9517 .data = TestBuffer::createFromVector<float>({}),
9518 .dimensions = {5, 2},
9519 .isIgnored = false,
9520 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9521 .numberOfConsumers = 1,
9522 .scale = 0.0f,
9523 .type = TestOperandType::TENSOR_FLOAT32,
9524 .zeroPoint = 0
9525 }, { // param2
9526 .channelQuant = {},
9527 .data = TestBuffer::createFromVector<float>({1.0f}),
9528 .dimensions = {},
9529 .isIgnored = false,
9530 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9531 .numberOfConsumers = 1,
9532 .scale = 0.0f,
9533 .type = TestOperandType::FLOAT32,
9534 .zeroPoint = 0
9535 }, { // axis
9536 .channelQuant = {},
9537 .data = TestBuffer::createFromVector<int32_t>({-2}),
9538 .dimensions = {},
9539 .isIgnored = false,
9540 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9541 .numberOfConsumers = 1,
9542 .scale = 0.0f,
9543 .type = TestOperandType::INT32,
9544 .zeroPoint = 0
9545 }, { // op2
9546 .channelQuant = {},
9547 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.643914213228014f, 0.236882800924671f, 0.236882800924671f, 0.087144312427294f, 0.087144312427294f, 0.032058600957022f, 0.032058600957022f, 7.246299848982885e-08f, 7.246299848982885e-08f}),
9548 .dimensions = {5, 2},
9549 .isIgnored = false,
9550 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9551 .numberOfConsumers = 0,
9552 .scale = 0.0f,
9553 .type = TestOperandType::TENSOR_FLOAT32,
9554 .zeroPoint = 0
9555 }, { // op1_new
9556 .channelQuant = {},
9557 .data = TestBuffer::createFromVector<float>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
9558 .dimensions = {5, 2},
9559 .isIgnored = false,
9560 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9561 .numberOfConsumers = 1,
9562 .scale = 0.0f,
9563 .type = TestOperandType::TENSOR_FLOAT32,
9564 .zeroPoint = 0
9565 }, { // placeholder59
9566 .channelQuant = {},
9567 .data = TestBuffer::createFromVector<float>({0.0f}),
9568 .dimensions = {1},
9569 .isIgnored = false,
9570 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9571 .numberOfConsumers = 1,
9572 .scale = 0.0f,
9573 .type = TestOperandType::TENSOR_FLOAT32,
9574 .zeroPoint = 0
9575 }, { // param77
9576 .channelQuant = {},
9577 .data = TestBuffer::createFromVector<int32_t>({0}),
9578 .dimensions = {},
9579 .isIgnored = false,
9580 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9581 .numberOfConsumers = 1,
9582 .scale = 0.0f,
9583 .type = TestOperandType::INT32,
9584 .zeroPoint = 0
9585 }},
9586 .operations = {{
9587 .inputs = {4, 5, 6},
9588 .outputs = {0},
9589 .type = TestOperationType::ADD
9590 }, {
9591 .inputs = {0, 1, 2},
9592 .outputs = {3},
9593 .type = TestOperationType::SOFTMAX
9594 }},
9595 .outputIndexes = {3}
9596 },
9597 .minSupportedVersion = TestHalVersion::UNKNOWN,
9598 .referenced = {}
9599 };
9600 return model;
9601 }
9602
9603 const auto dummy_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal());
9604
9605 } // namespace generated_tests::softmax_v1_2
9606
9607 namespace generated_tests::softmax_v1_2 {
9608
get_test_model_axis_relaxed_dim2_axis1()9609 const TestModel& get_test_model_axis_relaxed_dim2_axis1() {
9610 static TestModel model = {
9611 .expectFailure = false,
9612 .expectedMultinomialDistributionTolerance = 0,
9613 .isRelaxed = true,
9614 .main = { // axis
9615 .inputIndexes = {0},
9616 .operands = {{ // op1
9617 .channelQuant = {},
9618 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
9619 .dimensions = {2, 5},
9620 .isIgnored = false,
9621 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9622 .numberOfConsumers = 1,
9623 .scale = 0.0f,
9624 .type = TestOperandType::TENSOR_FLOAT32,
9625 .zeroPoint = 0
9626 }, { // param2
9627 .channelQuant = {},
9628 .data = TestBuffer::createFromVector<float>({1.0f}),
9629 .dimensions = {},
9630 .isIgnored = false,
9631 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9632 .numberOfConsumers = 1,
9633 .scale = 0.0f,
9634 .type = TestOperandType::FLOAT32,
9635 .zeroPoint = 0
9636 }, { // axis
9637 .channelQuant = {},
9638 .data = TestBuffer::createFromVector<int32_t>({1}),
9639 .dimensions = {},
9640 .isIgnored = false,
9641 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9642 .numberOfConsumers = 1,
9643 .scale = 0.0f,
9644 .type = TestOperandType::INT32,
9645 .zeroPoint = 0
9646 }, { // op2
9647 .channelQuant = {},
9648 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9649 .dimensions = {2, 5},
9650 .isIgnored = false,
9651 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9652 .numberOfConsumers = 0,
9653 .scale = 0.0f,
9654 .type = TestOperandType::TENSOR_FLOAT32,
9655 .zeroPoint = 0
9656 }},
9657 .operations = {{
9658 .inputs = {0, 1, 2},
9659 .outputs = {3},
9660 .type = TestOperationType::SOFTMAX
9661 }},
9662 .outputIndexes = {3}
9663 },
9664 .minSupportedVersion = TestHalVersion::UNKNOWN,
9665 .referenced = {}
9666 };
9667 return model;
9668 }
9669
9670 const auto dummy_test_model_axis_relaxed_dim2_axis1 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1", get_test_model_axis_relaxed_dim2_axis1());
9671
9672 } // namespace generated_tests::softmax_v1_2
9673
9674 namespace generated_tests::softmax_v1_2 {
9675
get_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal()9676 const TestModel& get_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal() {
9677 static TestModel model = {
9678 .expectFailure = false,
9679 .expectedMultinomialDistributionTolerance = 0,
9680 .isRelaxed = true,
9681 .main = { // axis
9682 .inputIndexes = {4},
9683 .operands = {{ // op1
9684 .channelQuant = {},
9685 .data = TestBuffer::createFromVector<float>({}),
9686 .dimensions = {2, 5},
9687 .isIgnored = false,
9688 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9689 .numberOfConsumers = 1,
9690 .scale = 0.0f,
9691 .type = TestOperandType::TENSOR_FLOAT32,
9692 .zeroPoint = 0
9693 }, { // param2
9694 .channelQuant = {},
9695 .data = TestBuffer::createFromVector<float>({1.0f}),
9696 .dimensions = {},
9697 .isIgnored = false,
9698 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9699 .numberOfConsumers = 1,
9700 .scale = 0.0f,
9701 .type = TestOperandType::FLOAT32,
9702 .zeroPoint = 0
9703 }, { // axis
9704 .channelQuant = {},
9705 .data = TestBuffer::createFromVector<int32_t>({1}),
9706 .dimensions = {},
9707 .isIgnored = false,
9708 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9709 .numberOfConsumers = 1,
9710 .scale = 0.0f,
9711 .type = TestOperandType::INT32,
9712 .zeroPoint = 0
9713 }, { // op2
9714 .channelQuant = {},
9715 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9716 .dimensions = {2, 5},
9717 .isIgnored = false,
9718 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9719 .numberOfConsumers = 0,
9720 .scale = 0.0f,
9721 .type = TestOperandType::TENSOR_FLOAT32,
9722 .zeroPoint = 0
9723 }, { // op1_new
9724 .channelQuant = {},
9725 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
9726 .dimensions = {2, 5},
9727 .isIgnored = false,
9728 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9729 .numberOfConsumers = 1,
9730 .scale = 0.0f,
9731 .type = TestOperandType::TENSOR_FLOAT32,
9732 .zeroPoint = 0
9733 }, { // placeholder60
9734 .channelQuant = {},
9735 .data = TestBuffer::createFromVector<float>({0.0f}),
9736 .dimensions = {1},
9737 .isIgnored = false,
9738 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9739 .numberOfConsumers = 1,
9740 .scale = 0.0f,
9741 .type = TestOperandType::TENSOR_FLOAT32,
9742 .zeroPoint = 0
9743 }, { // param78
9744 .channelQuant = {},
9745 .data = TestBuffer::createFromVector<int32_t>({0}),
9746 .dimensions = {},
9747 .isIgnored = false,
9748 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9749 .numberOfConsumers = 1,
9750 .scale = 0.0f,
9751 .type = TestOperandType::INT32,
9752 .zeroPoint = 0
9753 }},
9754 .operations = {{
9755 .inputs = {4, 5, 6},
9756 .outputs = {0},
9757 .type = TestOperationType::ADD
9758 }, {
9759 .inputs = {0, 1, 2},
9760 .outputs = {3},
9761 .type = TestOperationType::SOFTMAX
9762 }},
9763 .outputIndexes = {3}
9764 },
9765 .minSupportedVersion = TestHalVersion::UNKNOWN,
9766 .referenced = {}
9767 };
9768 return model;
9769 }
9770
9771 const auto dummy_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1_all_inputs_as_internal", get_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal());
9772
9773 } // namespace generated_tests::softmax_v1_2
9774
9775 namespace generated_tests::softmax_v1_2 {
9776
get_test_model_axis_relaxed_dim2_axis1_neg()9777 const TestModel& get_test_model_axis_relaxed_dim2_axis1_neg() {
9778 static TestModel model = {
9779 .expectFailure = false,
9780 .expectedMultinomialDistributionTolerance = 0,
9781 .isRelaxed = true,
9782 .main = { // axis
9783 .inputIndexes = {0},
9784 .operands = {{ // op1
9785 .channelQuant = {},
9786 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
9787 .dimensions = {2, 5},
9788 .isIgnored = false,
9789 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9790 .numberOfConsumers = 1,
9791 .scale = 0.0f,
9792 .type = TestOperandType::TENSOR_FLOAT32,
9793 .zeroPoint = 0
9794 }, { // param2
9795 .channelQuant = {},
9796 .data = TestBuffer::createFromVector<float>({1.0f}),
9797 .dimensions = {},
9798 .isIgnored = false,
9799 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9800 .numberOfConsumers = 1,
9801 .scale = 0.0f,
9802 .type = TestOperandType::FLOAT32,
9803 .zeroPoint = 0
9804 }, { // axis
9805 .channelQuant = {},
9806 .data = TestBuffer::createFromVector<int32_t>({-1}),
9807 .dimensions = {},
9808 .isIgnored = false,
9809 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9810 .numberOfConsumers = 1,
9811 .scale = 0.0f,
9812 .type = TestOperandType::INT32,
9813 .zeroPoint = 0
9814 }, { // op2
9815 .channelQuant = {},
9816 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9817 .dimensions = {2, 5},
9818 .isIgnored = false,
9819 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9820 .numberOfConsumers = 0,
9821 .scale = 0.0f,
9822 .type = TestOperandType::TENSOR_FLOAT32,
9823 .zeroPoint = 0
9824 }},
9825 .operations = {{
9826 .inputs = {0, 1, 2},
9827 .outputs = {3},
9828 .type = TestOperationType::SOFTMAX
9829 }},
9830 .outputIndexes = {3}
9831 },
9832 .minSupportedVersion = TestHalVersion::UNKNOWN,
9833 .referenced = {}
9834 };
9835 return model;
9836 }
9837
9838 const auto dummy_test_model_axis_relaxed_dim2_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1_neg", get_test_model_axis_relaxed_dim2_axis1_neg());
9839
9840 } // namespace generated_tests::softmax_v1_2
9841
9842 namespace generated_tests::softmax_v1_2 {
9843
get_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal()9844 const TestModel& get_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal() {
9845 static TestModel model = {
9846 .expectFailure = false,
9847 .expectedMultinomialDistributionTolerance = 0,
9848 .isRelaxed = true,
9849 .main = { // axis
9850 .inputIndexes = {4},
9851 .operands = {{ // op1
9852 .channelQuant = {},
9853 .data = TestBuffer::createFromVector<float>({}),
9854 .dimensions = {2, 5},
9855 .isIgnored = false,
9856 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9857 .numberOfConsumers = 1,
9858 .scale = 0.0f,
9859 .type = TestOperandType::TENSOR_FLOAT32,
9860 .zeroPoint = 0
9861 }, { // param2
9862 .channelQuant = {},
9863 .data = TestBuffer::createFromVector<float>({1.0f}),
9864 .dimensions = {},
9865 .isIgnored = false,
9866 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9867 .numberOfConsumers = 1,
9868 .scale = 0.0f,
9869 .type = TestOperandType::FLOAT32,
9870 .zeroPoint = 0
9871 }, { // axis
9872 .channelQuant = {},
9873 .data = TestBuffer::createFromVector<int32_t>({-1}),
9874 .dimensions = {},
9875 .isIgnored = false,
9876 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9877 .numberOfConsumers = 1,
9878 .scale = 0.0f,
9879 .type = TestOperandType::INT32,
9880 .zeroPoint = 0
9881 }, { // op2
9882 .channelQuant = {},
9883 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f, 0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9884 .dimensions = {2, 5},
9885 .isIgnored = false,
9886 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9887 .numberOfConsumers = 0,
9888 .scale = 0.0f,
9889 .type = TestOperandType::TENSOR_FLOAT32,
9890 .zeroPoint = 0
9891 }, { // op1_new
9892 .channelQuant = {},
9893 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
9894 .dimensions = {2, 5},
9895 .isIgnored = false,
9896 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9897 .numberOfConsumers = 1,
9898 .scale = 0.0f,
9899 .type = TestOperandType::TENSOR_FLOAT32,
9900 .zeroPoint = 0
9901 }, { // placeholder61
9902 .channelQuant = {},
9903 .data = TestBuffer::createFromVector<float>({0.0f}),
9904 .dimensions = {1},
9905 .isIgnored = false,
9906 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9907 .numberOfConsumers = 1,
9908 .scale = 0.0f,
9909 .type = TestOperandType::TENSOR_FLOAT32,
9910 .zeroPoint = 0
9911 }, { // param79
9912 .channelQuant = {},
9913 .data = TestBuffer::createFromVector<int32_t>({0}),
9914 .dimensions = {},
9915 .isIgnored = false,
9916 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9917 .numberOfConsumers = 1,
9918 .scale = 0.0f,
9919 .type = TestOperandType::INT32,
9920 .zeroPoint = 0
9921 }},
9922 .operations = {{
9923 .inputs = {4, 5, 6},
9924 .outputs = {0},
9925 .type = TestOperationType::ADD
9926 }, {
9927 .inputs = {0, 1, 2},
9928 .outputs = {3},
9929 .type = TestOperationType::SOFTMAX
9930 }},
9931 .outputIndexes = {3}
9932 },
9933 .minSupportedVersion = TestHalVersion::UNKNOWN,
9934 .referenced = {}
9935 };
9936 return model;
9937 }
9938
9939 const auto dummy_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal());
9940
9941 } // namespace generated_tests::softmax_v1_2
9942
9943 namespace generated_tests::softmax_v1_2 {
9944
get_test_model_axis_relaxed_dim1_axis0()9945 const TestModel& get_test_model_axis_relaxed_dim1_axis0() {
9946 static TestModel model = {
9947 .expectFailure = false,
9948 .expectedMultinomialDistributionTolerance = 0,
9949 .isRelaxed = true,
9950 .main = { // axis
9951 .inputIndexes = {0},
9952 .operands = {{ // op1
9953 .channelQuant = {},
9954 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
9955 .dimensions = {5},
9956 .isIgnored = false,
9957 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9958 .numberOfConsumers = 1,
9959 .scale = 0.0f,
9960 .type = TestOperandType::TENSOR_FLOAT32,
9961 .zeroPoint = 0
9962 }, { // param2
9963 .channelQuant = {},
9964 .data = TestBuffer::createFromVector<float>({1.0f}),
9965 .dimensions = {},
9966 .isIgnored = false,
9967 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9968 .numberOfConsumers = 1,
9969 .scale = 0.0f,
9970 .type = TestOperandType::FLOAT32,
9971 .zeroPoint = 0
9972 }, { // axis
9973 .channelQuant = {},
9974 .data = TestBuffer::createFromVector<int32_t>({0}),
9975 .dimensions = {},
9976 .isIgnored = false,
9977 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9978 .numberOfConsumers = 1,
9979 .scale = 0.0f,
9980 .type = TestOperandType::INT32,
9981 .zeroPoint = 0
9982 }, { // op2
9983 .channelQuant = {},
9984 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
9985 .dimensions = {5},
9986 .isIgnored = false,
9987 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9988 .numberOfConsumers = 0,
9989 .scale = 0.0f,
9990 .type = TestOperandType::TENSOR_FLOAT32,
9991 .zeroPoint = 0
9992 }},
9993 .operations = {{
9994 .inputs = {0, 1, 2},
9995 .outputs = {3},
9996 .type = TestOperationType::SOFTMAX
9997 }},
9998 .outputIndexes = {3}
9999 },
10000 .minSupportedVersion = TestHalVersion::UNKNOWN,
10001 .referenced = {}
10002 };
10003 return model;
10004 }
10005
10006 const auto dummy_test_model_axis_relaxed_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0", get_test_model_axis_relaxed_dim1_axis0());
10007
10008 } // namespace generated_tests::softmax_v1_2
10009
10010 namespace generated_tests::softmax_v1_2 {
10011
get_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal()10012 const TestModel& get_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal() {
10013 static TestModel model = {
10014 .expectFailure = false,
10015 .expectedMultinomialDistributionTolerance = 0,
10016 .isRelaxed = true,
10017 .main = { // axis
10018 .inputIndexes = {4},
10019 .operands = {{ // op1
10020 .channelQuant = {},
10021 .data = TestBuffer::createFromVector<float>({}),
10022 .dimensions = {5},
10023 .isIgnored = false,
10024 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10025 .numberOfConsumers = 1,
10026 .scale = 0.0f,
10027 .type = TestOperandType::TENSOR_FLOAT32,
10028 .zeroPoint = 0
10029 }, { // param2
10030 .channelQuant = {},
10031 .data = TestBuffer::createFromVector<float>({1.0f}),
10032 .dimensions = {},
10033 .isIgnored = false,
10034 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10035 .numberOfConsumers = 1,
10036 .scale = 0.0f,
10037 .type = TestOperandType::FLOAT32,
10038 .zeroPoint = 0
10039 }, { // axis
10040 .channelQuant = {},
10041 .data = TestBuffer::createFromVector<int32_t>({0}),
10042 .dimensions = {},
10043 .isIgnored = false,
10044 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10045 .numberOfConsumers = 1,
10046 .scale = 0.0f,
10047 .type = TestOperandType::INT32,
10048 .zeroPoint = 0
10049 }, { // op2
10050 .channelQuant = {},
10051 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
10052 .dimensions = {5},
10053 .isIgnored = false,
10054 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10055 .numberOfConsumers = 0,
10056 .scale = 0.0f,
10057 .type = TestOperandType::TENSOR_FLOAT32,
10058 .zeroPoint = 0
10059 }, { // op1_new
10060 .channelQuant = {},
10061 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
10062 .dimensions = {5},
10063 .isIgnored = false,
10064 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10065 .numberOfConsumers = 1,
10066 .scale = 0.0f,
10067 .type = TestOperandType::TENSOR_FLOAT32,
10068 .zeroPoint = 0
10069 }, { // placeholder62
10070 .channelQuant = {},
10071 .data = TestBuffer::createFromVector<float>({0.0f}),
10072 .dimensions = {1},
10073 .isIgnored = false,
10074 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10075 .numberOfConsumers = 1,
10076 .scale = 0.0f,
10077 .type = TestOperandType::TENSOR_FLOAT32,
10078 .zeroPoint = 0
10079 }, { // param80
10080 .channelQuant = {},
10081 .data = TestBuffer::createFromVector<int32_t>({0}),
10082 .dimensions = {},
10083 .isIgnored = false,
10084 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10085 .numberOfConsumers = 1,
10086 .scale = 0.0f,
10087 .type = TestOperandType::INT32,
10088 .zeroPoint = 0
10089 }},
10090 .operations = {{
10091 .inputs = {4, 5, 6},
10092 .outputs = {0},
10093 .type = TestOperationType::ADD
10094 }, {
10095 .inputs = {0, 1, 2},
10096 .outputs = {3},
10097 .type = TestOperationType::SOFTMAX
10098 }},
10099 .outputIndexes = {3}
10100 },
10101 .minSupportedVersion = TestHalVersion::UNKNOWN,
10102 .referenced = {}
10103 };
10104 return model;
10105 }
10106
10107 const auto dummy_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0_all_inputs_as_internal", get_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal());
10108
10109 } // namespace generated_tests::softmax_v1_2
10110
10111 namespace generated_tests::softmax_v1_2 {
10112
get_test_model_axis_relaxed_dim1_axis0_neg()10113 const TestModel& get_test_model_axis_relaxed_dim1_axis0_neg() {
10114 static TestModel model = {
10115 .expectFailure = false,
10116 .expectedMultinomialDistributionTolerance = 0,
10117 .isRelaxed = true,
10118 .main = { // axis
10119 .inputIndexes = {0},
10120 .operands = {{ // op1
10121 .channelQuant = {},
10122 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
10123 .dimensions = {5},
10124 .isIgnored = false,
10125 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10126 .numberOfConsumers = 1,
10127 .scale = 0.0f,
10128 .type = TestOperandType::TENSOR_FLOAT32,
10129 .zeroPoint = 0
10130 }, { // param2
10131 .channelQuant = {},
10132 .data = TestBuffer::createFromVector<float>({1.0f}),
10133 .dimensions = {},
10134 .isIgnored = false,
10135 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10136 .numberOfConsumers = 1,
10137 .scale = 0.0f,
10138 .type = TestOperandType::FLOAT32,
10139 .zeroPoint = 0
10140 }, { // axis
10141 .channelQuant = {},
10142 .data = TestBuffer::createFromVector<int32_t>({-1}),
10143 .dimensions = {},
10144 .isIgnored = false,
10145 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10146 .numberOfConsumers = 1,
10147 .scale = 0.0f,
10148 .type = TestOperandType::INT32,
10149 .zeroPoint = 0
10150 }, { // op2
10151 .channelQuant = {},
10152 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
10153 .dimensions = {5},
10154 .isIgnored = false,
10155 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10156 .numberOfConsumers = 0,
10157 .scale = 0.0f,
10158 .type = TestOperandType::TENSOR_FLOAT32,
10159 .zeroPoint = 0
10160 }},
10161 .operations = {{
10162 .inputs = {0, 1, 2},
10163 .outputs = {3},
10164 .type = TestOperationType::SOFTMAX
10165 }},
10166 .outputIndexes = {3}
10167 },
10168 .minSupportedVersion = TestHalVersion::UNKNOWN,
10169 .referenced = {}
10170 };
10171 return model;
10172 }
10173
10174 const auto dummy_test_model_axis_relaxed_dim1_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0_neg", get_test_model_axis_relaxed_dim1_axis0_neg());
10175
10176 } // namespace generated_tests::softmax_v1_2
10177
10178 namespace generated_tests::softmax_v1_2 {
10179
get_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal()10180 const TestModel& get_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal() {
10181 static TestModel model = {
10182 .expectFailure = false,
10183 .expectedMultinomialDistributionTolerance = 0,
10184 .isRelaxed = true,
10185 .main = { // axis
10186 .inputIndexes = {4},
10187 .operands = {{ // op1
10188 .channelQuant = {},
10189 .data = TestBuffer::createFromVector<float>({}),
10190 .dimensions = {5},
10191 .isIgnored = false,
10192 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10193 .numberOfConsumers = 1,
10194 .scale = 0.0f,
10195 .type = TestOperandType::TENSOR_FLOAT32,
10196 .zeroPoint = 0
10197 }, { // param2
10198 .channelQuant = {},
10199 .data = TestBuffer::createFromVector<float>({1.0f}),
10200 .dimensions = {},
10201 .isIgnored = false,
10202 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10203 .numberOfConsumers = 1,
10204 .scale = 0.0f,
10205 .type = TestOperandType::FLOAT32,
10206 .zeroPoint = 0
10207 }, { // axis
10208 .channelQuant = {},
10209 .data = TestBuffer::createFromVector<int32_t>({-1}),
10210 .dimensions = {},
10211 .isIgnored = false,
10212 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10213 .numberOfConsumers = 1,
10214 .scale = 0.0f,
10215 .type = TestOperandType::INT32,
10216 .zeroPoint = 0
10217 }, { // op2
10218 .channelQuant = {},
10219 .data = TestBuffer::createFromVector<float>({0.643914213228014f, 0.236882800924671f, 0.087144312427294f, 0.032058600957022f, 7.246299848982885e-08f}),
10220 .dimensions = {5},
10221 .isIgnored = false,
10222 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10223 .numberOfConsumers = 0,
10224 .scale = 0.0f,
10225 .type = TestOperandType::TENSOR_FLOAT32,
10226 .zeroPoint = 0
10227 }, { // op1_new
10228 .channelQuant = {},
10229 .data = TestBuffer::createFromVector<float>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
10230 .dimensions = {5},
10231 .isIgnored = false,
10232 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10233 .numberOfConsumers = 1,
10234 .scale = 0.0f,
10235 .type = TestOperandType::TENSOR_FLOAT32,
10236 .zeroPoint = 0
10237 }, { // placeholder63
10238 .channelQuant = {},
10239 .data = TestBuffer::createFromVector<float>({0.0f}),
10240 .dimensions = {1},
10241 .isIgnored = false,
10242 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10243 .numberOfConsumers = 1,
10244 .scale = 0.0f,
10245 .type = TestOperandType::TENSOR_FLOAT32,
10246 .zeroPoint = 0
10247 }, { // param81
10248 .channelQuant = {},
10249 .data = TestBuffer::createFromVector<int32_t>({0}),
10250 .dimensions = {},
10251 .isIgnored = false,
10252 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10253 .numberOfConsumers = 1,
10254 .scale = 0.0f,
10255 .type = TestOperandType::INT32,
10256 .zeroPoint = 0
10257 }},
10258 .operations = {{
10259 .inputs = {4, 5, 6},
10260 .outputs = {0},
10261 .type = TestOperationType::ADD
10262 }, {
10263 .inputs = {0, 1, 2},
10264 .outputs = {3},
10265 .type = TestOperationType::SOFTMAX
10266 }},
10267 .outputIndexes = {3}
10268 },
10269 .minSupportedVersion = TestHalVersion::UNKNOWN,
10270 .referenced = {}
10271 };
10272 return model;
10273 }
10274
10275 const auto dummy_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal", get_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal());
10276
10277 } // namespace generated_tests::softmax_v1_2
10278
10279 namespace generated_tests::softmax_v1_2 {
10280
get_test_model_axis_float16_dim4_axis0()10281 const TestModel& get_test_model_axis_float16_dim4_axis0() {
10282 static TestModel model = {
10283 .expectFailure = false,
10284 .expectedMultinomialDistributionTolerance = 0,
10285 .isRelaxed = false,
10286 .main = { // axis
10287 .inputIndexes = {0},
10288 .operands = {{ // op1
10289 .channelQuant = {},
10290 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10291 .dimensions = {5, 2, 2, 2},
10292 .isIgnored = false,
10293 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10294 .numberOfConsumers = 1,
10295 .scale = 0.0f,
10296 .type = TestOperandType::TENSOR_FLOAT16,
10297 .zeroPoint = 0
10298 }, { // param2
10299 .channelQuant = {},
10300 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10301 .dimensions = {},
10302 .isIgnored = false,
10303 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10304 .numberOfConsumers = 1,
10305 .scale = 0.0f,
10306 .type = TestOperandType::FLOAT16,
10307 .zeroPoint = 0
10308 }, { // axis
10309 .channelQuant = {},
10310 .data = TestBuffer::createFromVector<int32_t>({0}),
10311 .dimensions = {},
10312 .isIgnored = false,
10313 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10314 .numberOfConsumers = 1,
10315 .scale = 0.0f,
10316 .type = TestOperandType::INT32,
10317 .zeroPoint = 0
10318 }, { // op2
10319 .channelQuant = {},
10320 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10321 .dimensions = {5, 2, 2, 2},
10322 .isIgnored = false,
10323 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10324 .numberOfConsumers = 0,
10325 .scale = 0.0f,
10326 .type = TestOperandType::TENSOR_FLOAT16,
10327 .zeroPoint = 0
10328 }},
10329 .operations = {{
10330 .inputs = {0, 1, 2},
10331 .outputs = {3},
10332 .type = TestOperationType::SOFTMAX
10333 }},
10334 .outputIndexes = {3}
10335 },
10336 .minSupportedVersion = TestHalVersion::V1_2,
10337 .referenced = {}
10338 };
10339 return model;
10340 }
10341
10342 const auto dummy_test_model_axis_float16_dim4_axis0 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0", get_test_model_axis_float16_dim4_axis0());
10343
10344 } // namespace generated_tests::softmax_v1_2
10345
10346 namespace generated_tests::softmax_v1_2 {
10347
get_test_model_axis_float16_dim4_axis0_all_inputs_as_internal()10348 const TestModel& get_test_model_axis_float16_dim4_axis0_all_inputs_as_internal() {
10349 static TestModel model = {
10350 .expectFailure = false,
10351 .expectedMultinomialDistributionTolerance = 0,
10352 .isRelaxed = false,
10353 .main = { // axis
10354 .inputIndexes = {4},
10355 .operands = {{ // op1
10356 .channelQuant = {},
10357 .data = TestBuffer::createFromVector<_Float16>({}),
10358 .dimensions = {5, 2, 2, 2},
10359 .isIgnored = false,
10360 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10361 .numberOfConsumers = 1,
10362 .scale = 0.0f,
10363 .type = TestOperandType::TENSOR_FLOAT16,
10364 .zeroPoint = 0
10365 }, { // param2
10366 .channelQuant = {},
10367 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10368 .dimensions = {},
10369 .isIgnored = false,
10370 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10371 .numberOfConsumers = 1,
10372 .scale = 0.0f,
10373 .type = TestOperandType::FLOAT16,
10374 .zeroPoint = 0
10375 }, { // axis
10376 .channelQuant = {},
10377 .data = TestBuffer::createFromVector<int32_t>({0}),
10378 .dimensions = {},
10379 .isIgnored = false,
10380 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10381 .numberOfConsumers = 1,
10382 .scale = 0.0f,
10383 .type = TestOperandType::INT32,
10384 .zeroPoint = 0
10385 }, { // op2
10386 .channelQuant = {},
10387 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10388 .dimensions = {5, 2, 2, 2},
10389 .isIgnored = false,
10390 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10391 .numberOfConsumers = 0,
10392 .scale = 0.0f,
10393 .type = TestOperandType::TENSOR_FLOAT16,
10394 .zeroPoint = 0
10395 }, { // op1_new
10396 .channelQuant = {},
10397 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10398 .dimensions = {5, 2, 2, 2},
10399 .isIgnored = false,
10400 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10401 .numberOfConsumers = 1,
10402 .scale = 0.0f,
10403 .type = TestOperandType::TENSOR_FLOAT16,
10404 .zeroPoint = 0
10405 }, { // placeholder64
10406 .channelQuant = {},
10407 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
10408 .dimensions = {1},
10409 .isIgnored = false,
10410 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10411 .numberOfConsumers = 1,
10412 .scale = 0.0f,
10413 .type = TestOperandType::TENSOR_FLOAT16,
10414 .zeroPoint = 0
10415 }, { // param82
10416 .channelQuant = {},
10417 .data = TestBuffer::createFromVector<int32_t>({0}),
10418 .dimensions = {},
10419 .isIgnored = false,
10420 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10421 .numberOfConsumers = 1,
10422 .scale = 0.0f,
10423 .type = TestOperandType::INT32,
10424 .zeroPoint = 0
10425 }},
10426 .operations = {{
10427 .inputs = {4, 5, 6},
10428 .outputs = {0},
10429 .type = TestOperationType::ADD
10430 }, {
10431 .inputs = {0, 1, 2},
10432 .outputs = {3},
10433 .type = TestOperationType::SOFTMAX
10434 }},
10435 .outputIndexes = {3}
10436 },
10437 .minSupportedVersion = TestHalVersion::V1_2,
10438 .referenced = {}
10439 };
10440 return model;
10441 }
10442
10443 const auto dummy_test_model_axis_float16_dim4_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis0_all_inputs_as_internal());
10444
10445 } // namespace generated_tests::softmax_v1_2
10446
10447 namespace generated_tests::softmax_v1_2 {
10448
get_test_model_axis_float16_dim4_axis0_neg()10449 const TestModel& get_test_model_axis_float16_dim4_axis0_neg() {
10450 static TestModel model = {
10451 .expectFailure = false,
10452 .expectedMultinomialDistributionTolerance = 0,
10453 .isRelaxed = false,
10454 .main = { // axis
10455 .inputIndexes = {0},
10456 .operands = {{ // op1
10457 .channelQuant = {},
10458 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10459 .dimensions = {5, 2, 2, 2},
10460 .isIgnored = false,
10461 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10462 .numberOfConsumers = 1,
10463 .scale = 0.0f,
10464 .type = TestOperandType::TENSOR_FLOAT16,
10465 .zeroPoint = 0
10466 }, { // param2
10467 .channelQuant = {},
10468 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10469 .dimensions = {},
10470 .isIgnored = false,
10471 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10472 .numberOfConsumers = 1,
10473 .scale = 0.0f,
10474 .type = TestOperandType::FLOAT16,
10475 .zeroPoint = 0
10476 }, { // axis
10477 .channelQuant = {},
10478 .data = TestBuffer::createFromVector<int32_t>({-4}),
10479 .dimensions = {},
10480 .isIgnored = false,
10481 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10482 .numberOfConsumers = 1,
10483 .scale = 0.0f,
10484 .type = TestOperandType::INT32,
10485 .zeroPoint = 0
10486 }, { // op2
10487 .channelQuant = {},
10488 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10489 .dimensions = {5, 2, 2, 2},
10490 .isIgnored = false,
10491 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10492 .numberOfConsumers = 0,
10493 .scale = 0.0f,
10494 .type = TestOperandType::TENSOR_FLOAT16,
10495 .zeroPoint = 0
10496 }},
10497 .operations = {{
10498 .inputs = {0, 1, 2},
10499 .outputs = {3},
10500 .type = TestOperationType::SOFTMAX
10501 }},
10502 .outputIndexes = {3}
10503 },
10504 .minSupportedVersion = TestHalVersion::V1_2,
10505 .referenced = {}
10506 };
10507 return model;
10508 }
10509
10510 const auto dummy_test_model_axis_float16_dim4_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0_neg", get_test_model_axis_float16_dim4_axis0_neg());
10511
10512 } // namespace generated_tests::softmax_v1_2
10513
10514 namespace generated_tests::softmax_v1_2 {
10515
get_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal()10516 const TestModel& get_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal() {
10517 static TestModel model = {
10518 .expectFailure = false,
10519 .expectedMultinomialDistributionTolerance = 0,
10520 .isRelaxed = false,
10521 .main = { // axis
10522 .inputIndexes = {4},
10523 .operands = {{ // op1
10524 .channelQuant = {},
10525 .data = TestBuffer::createFromVector<_Float16>({}),
10526 .dimensions = {5, 2, 2, 2},
10527 .isIgnored = false,
10528 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10529 .numberOfConsumers = 1,
10530 .scale = 0.0f,
10531 .type = TestOperandType::TENSOR_FLOAT16,
10532 .zeroPoint = 0
10533 }, { // param2
10534 .channelQuant = {},
10535 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10536 .dimensions = {},
10537 .isIgnored = false,
10538 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10539 .numberOfConsumers = 1,
10540 .scale = 0.0f,
10541 .type = TestOperandType::FLOAT16,
10542 .zeroPoint = 0
10543 }, { // axis
10544 .channelQuant = {},
10545 .data = TestBuffer::createFromVector<int32_t>({-4}),
10546 .dimensions = {},
10547 .isIgnored = false,
10548 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10549 .numberOfConsumers = 1,
10550 .scale = 0.0f,
10551 .type = TestOperandType::INT32,
10552 .zeroPoint = 0
10553 }, { // op2
10554 .channelQuant = {},
10555 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10556 .dimensions = {5, 2, 2, 2},
10557 .isIgnored = false,
10558 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10559 .numberOfConsumers = 0,
10560 .scale = 0.0f,
10561 .type = TestOperandType::TENSOR_FLOAT16,
10562 .zeroPoint = 0
10563 }, { // op1_new
10564 .channelQuant = {},
10565 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10566 .dimensions = {5, 2, 2, 2},
10567 .isIgnored = false,
10568 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10569 .numberOfConsumers = 1,
10570 .scale = 0.0f,
10571 .type = TestOperandType::TENSOR_FLOAT16,
10572 .zeroPoint = 0
10573 }, { // placeholder65
10574 .channelQuant = {},
10575 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
10576 .dimensions = {1},
10577 .isIgnored = false,
10578 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10579 .numberOfConsumers = 1,
10580 .scale = 0.0f,
10581 .type = TestOperandType::TENSOR_FLOAT16,
10582 .zeroPoint = 0
10583 }, { // param83
10584 .channelQuant = {},
10585 .data = TestBuffer::createFromVector<int32_t>({0}),
10586 .dimensions = {},
10587 .isIgnored = false,
10588 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10589 .numberOfConsumers = 1,
10590 .scale = 0.0f,
10591 .type = TestOperandType::INT32,
10592 .zeroPoint = 0
10593 }},
10594 .operations = {{
10595 .inputs = {4, 5, 6},
10596 .outputs = {0},
10597 .type = TestOperationType::ADD
10598 }, {
10599 .inputs = {0, 1, 2},
10600 .outputs = {3},
10601 .type = TestOperationType::SOFTMAX
10602 }},
10603 .outputIndexes = {3}
10604 },
10605 .minSupportedVersion = TestHalVersion::V1_2,
10606 .referenced = {}
10607 };
10608 return model;
10609 }
10610
10611 const auto dummy_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0_neg_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal());
10612
10613 } // namespace generated_tests::softmax_v1_2
10614
10615 namespace generated_tests::softmax_v1_2 {
10616
get_test_model_axis_float16_dim4_axis1()10617 const TestModel& get_test_model_axis_float16_dim4_axis1() {
10618 static TestModel model = {
10619 .expectFailure = false,
10620 .expectedMultinomialDistributionTolerance = 0,
10621 .isRelaxed = false,
10622 .main = { // axis
10623 .inputIndexes = {0},
10624 .operands = {{ // op1
10625 .channelQuant = {},
10626 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10627 .dimensions = {2, 5, 2, 2},
10628 .isIgnored = false,
10629 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10630 .numberOfConsumers = 1,
10631 .scale = 0.0f,
10632 .type = TestOperandType::TENSOR_FLOAT16,
10633 .zeroPoint = 0
10634 }, { // param2
10635 .channelQuant = {},
10636 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10637 .dimensions = {},
10638 .isIgnored = false,
10639 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10640 .numberOfConsumers = 1,
10641 .scale = 0.0f,
10642 .type = TestOperandType::FLOAT16,
10643 .zeroPoint = 0
10644 }, { // axis
10645 .channelQuant = {},
10646 .data = TestBuffer::createFromVector<int32_t>({1}),
10647 .dimensions = {},
10648 .isIgnored = false,
10649 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10650 .numberOfConsumers = 1,
10651 .scale = 0.0f,
10652 .type = TestOperandType::INT32,
10653 .zeroPoint = 0
10654 }, { // op2
10655 .channelQuant = {},
10656 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10657 .dimensions = {2, 5, 2, 2},
10658 .isIgnored = false,
10659 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10660 .numberOfConsumers = 0,
10661 .scale = 0.0f,
10662 .type = TestOperandType::TENSOR_FLOAT16,
10663 .zeroPoint = 0
10664 }},
10665 .operations = {{
10666 .inputs = {0, 1, 2},
10667 .outputs = {3},
10668 .type = TestOperationType::SOFTMAX
10669 }},
10670 .outputIndexes = {3}
10671 },
10672 .minSupportedVersion = TestHalVersion::V1_2,
10673 .referenced = {}
10674 };
10675 return model;
10676 }
10677
10678 const auto dummy_test_model_axis_float16_dim4_axis1 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1", get_test_model_axis_float16_dim4_axis1());
10679
10680 } // namespace generated_tests::softmax_v1_2
10681
10682 namespace generated_tests::softmax_v1_2 {
10683
get_test_model_axis_float16_dim4_axis1_all_inputs_as_internal()10684 const TestModel& get_test_model_axis_float16_dim4_axis1_all_inputs_as_internal() {
10685 static TestModel model = {
10686 .expectFailure = false,
10687 .expectedMultinomialDistributionTolerance = 0,
10688 .isRelaxed = false,
10689 .main = { // axis
10690 .inputIndexes = {4},
10691 .operands = {{ // op1
10692 .channelQuant = {},
10693 .data = TestBuffer::createFromVector<_Float16>({}),
10694 .dimensions = {2, 5, 2, 2},
10695 .isIgnored = false,
10696 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10697 .numberOfConsumers = 1,
10698 .scale = 0.0f,
10699 .type = TestOperandType::TENSOR_FLOAT16,
10700 .zeroPoint = 0
10701 }, { // param2
10702 .channelQuant = {},
10703 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10704 .dimensions = {},
10705 .isIgnored = false,
10706 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10707 .numberOfConsumers = 1,
10708 .scale = 0.0f,
10709 .type = TestOperandType::FLOAT16,
10710 .zeroPoint = 0
10711 }, { // axis
10712 .channelQuant = {},
10713 .data = TestBuffer::createFromVector<int32_t>({1}),
10714 .dimensions = {},
10715 .isIgnored = false,
10716 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10717 .numberOfConsumers = 1,
10718 .scale = 0.0f,
10719 .type = TestOperandType::INT32,
10720 .zeroPoint = 0
10721 }, { // op2
10722 .channelQuant = {},
10723 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10724 .dimensions = {2, 5, 2, 2},
10725 .isIgnored = false,
10726 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10727 .numberOfConsumers = 0,
10728 .scale = 0.0f,
10729 .type = TestOperandType::TENSOR_FLOAT16,
10730 .zeroPoint = 0
10731 }, { // op1_new
10732 .channelQuant = {},
10733 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10734 .dimensions = {2, 5, 2, 2},
10735 .isIgnored = false,
10736 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10737 .numberOfConsumers = 1,
10738 .scale = 0.0f,
10739 .type = TestOperandType::TENSOR_FLOAT16,
10740 .zeroPoint = 0
10741 }, { // placeholder66
10742 .channelQuant = {},
10743 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
10744 .dimensions = {1},
10745 .isIgnored = false,
10746 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10747 .numberOfConsumers = 1,
10748 .scale = 0.0f,
10749 .type = TestOperandType::TENSOR_FLOAT16,
10750 .zeroPoint = 0
10751 }, { // param84
10752 .channelQuant = {},
10753 .data = TestBuffer::createFromVector<int32_t>({0}),
10754 .dimensions = {},
10755 .isIgnored = false,
10756 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10757 .numberOfConsumers = 1,
10758 .scale = 0.0f,
10759 .type = TestOperandType::INT32,
10760 .zeroPoint = 0
10761 }},
10762 .operations = {{
10763 .inputs = {4, 5, 6},
10764 .outputs = {0},
10765 .type = TestOperationType::ADD
10766 }, {
10767 .inputs = {0, 1, 2},
10768 .outputs = {3},
10769 .type = TestOperationType::SOFTMAX
10770 }},
10771 .outputIndexes = {3}
10772 },
10773 .minSupportedVersion = TestHalVersion::V1_2,
10774 .referenced = {}
10775 };
10776 return model;
10777 }
10778
10779 const auto dummy_test_model_axis_float16_dim4_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis1_all_inputs_as_internal());
10780
10781 } // namespace generated_tests::softmax_v1_2
10782
10783 namespace generated_tests::softmax_v1_2 {
10784
get_test_model_axis_float16_dim4_axis1_neg()10785 const TestModel& get_test_model_axis_float16_dim4_axis1_neg() {
10786 static TestModel model = {
10787 .expectFailure = false,
10788 .expectedMultinomialDistributionTolerance = 0,
10789 .isRelaxed = false,
10790 .main = { // axis
10791 .inputIndexes = {0},
10792 .operands = {{ // op1
10793 .channelQuant = {},
10794 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10795 .dimensions = {2, 5, 2, 2},
10796 .isIgnored = false,
10797 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10798 .numberOfConsumers = 1,
10799 .scale = 0.0f,
10800 .type = TestOperandType::TENSOR_FLOAT16,
10801 .zeroPoint = 0
10802 }, { // param2
10803 .channelQuant = {},
10804 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10805 .dimensions = {},
10806 .isIgnored = false,
10807 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10808 .numberOfConsumers = 1,
10809 .scale = 0.0f,
10810 .type = TestOperandType::FLOAT16,
10811 .zeroPoint = 0
10812 }, { // axis
10813 .channelQuant = {},
10814 .data = TestBuffer::createFromVector<int32_t>({-3}),
10815 .dimensions = {},
10816 .isIgnored = false,
10817 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10818 .numberOfConsumers = 1,
10819 .scale = 0.0f,
10820 .type = TestOperandType::INT32,
10821 .zeroPoint = 0
10822 }, { // op2
10823 .channelQuant = {},
10824 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10825 .dimensions = {2, 5, 2, 2},
10826 .isIgnored = false,
10827 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10828 .numberOfConsumers = 0,
10829 .scale = 0.0f,
10830 .type = TestOperandType::TENSOR_FLOAT16,
10831 .zeroPoint = 0
10832 }},
10833 .operations = {{
10834 .inputs = {0, 1, 2},
10835 .outputs = {3},
10836 .type = TestOperationType::SOFTMAX
10837 }},
10838 .outputIndexes = {3}
10839 },
10840 .minSupportedVersion = TestHalVersion::V1_2,
10841 .referenced = {}
10842 };
10843 return model;
10844 }
10845
10846 const auto dummy_test_model_axis_float16_dim4_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1_neg", get_test_model_axis_float16_dim4_axis1_neg());
10847
10848 } // namespace generated_tests::softmax_v1_2
10849
10850 namespace generated_tests::softmax_v1_2 {
10851
get_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal()10852 const TestModel& get_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal() {
10853 static TestModel model = {
10854 .expectFailure = false,
10855 .expectedMultinomialDistributionTolerance = 0,
10856 .isRelaxed = false,
10857 .main = { // axis
10858 .inputIndexes = {4},
10859 .operands = {{ // op1
10860 .channelQuant = {},
10861 .data = TestBuffer::createFromVector<_Float16>({}),
10862 .dimensions = {2, 5, 2, 2},
10863 .isIgnored = false,
10864 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10865 .numberOfConsumers = 1,
10866 .scale = 0.0f,
10867 .type = TestOperandType::TENSOR_FLOAT16,
10868 .zeroPoint = 0
10869 }, { // param2
10870 .channelQuant = {},
10871 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10872 .dimensions = {},
10873 .isIgnored = false,
10874 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10875 .numberOfConsumers = 1,
10876 .scale = 0.0f,
10877 .type = TestOperandType::FLOAT16,
10878 .zeroPoint = 0
10879 }, { // axis
10880 .channelQuant = {},
10881 .data = TestBuffer::createFromVector<int32_t>({-3}),
10882 .dimensions = {},
10883 .isIgnored = false,
10884 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10885 .numberOfConsumers = 1,
10886 .scale = 0.0f,
10887 .type = TestOperandType::INT32,
10888 .zeroPoint = 0
10889 }, { // op2
10890 .channelQuant = {},
10891 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10892 .dimensions = {2, 5, 2, 2},
10893 .isIgnored = false,
10894 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10895 .numberOfConsumers = 0,
10896 .scale = 0.0f,
10897 .type = TestOperandType::TENSOR_FLOAT16,
10898 .zeroPoint = 0
10899 }, { // op1_new
10900 .channelQuant = {},
10901 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f, 17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
10902 .dimensions = {2, 5, 2, 2},
10903 .isIgnored = false,
10904 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10905 .numberOfConsumers = 1,
10906 .scale = 0.0f,
10907 .type = TestOperandType::TENSOR_FLOAT16,
10908 .zeroPoint = 0
10909 }, { // placeholder67
10910 .channelQuant = {},
10911 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
10912 .dimensions = {1},
10913 .isIgnored = false,
10914 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10915 .numberOfConsumers = 1,
10916 .scale = 0.0f,
10917 .type = TestOperandType::TENSOR_FLOAT16,
10918 .zeroPoint = 0
10919 }, { // param85
10920 .channelQuant = {},
10921 .data = TestBuffer::createFromVector<int32_t>({0}),
10922 .dimensions = {},
10923 .isIgnored = false,
10924 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10925 .numberOfConsumers = 1,
10926 .scale = 0.0f,
10927 .type = TestOperandType::INT32,
10928 .zeroPoint = 0
10929 }},
10930 .operations = {{
10931 .inputs = {4, 5, 6},
10932 .outputs = {0},
10933 .type = TestOperationType::ADD
10934 }, {
10935 .inputs = {0, 1, 2},
10936 .outputs = {3},
10937 .type = TestOperationType::SOFTMAX
10938 }},
10939 .outputIndexes = {3}
10940 },
10941 .minSupportedVersion = TestHalVersion::V1_2,
10942 .referenced = {}
10943 };
10944 return model;
10945 }
10946
10947 const auto dummy_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1_neg_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal());
10948
10949 } // namespace generated_tests::softmax_v1_2
10950
10951 namespace generated_tests::softmax_v1_2 {
10952
get_test_model_axis_float16_dim4_axis2()10953 const TestModel& get_test_model_axis_float16_dim4_axis2() {
10954 static TestModel model = {
10955 .expectFailure = false,
10956 .expectedMultinomialDistributionTolerance = 0,
10957 .isRelaxed = false,
10958 .main = { // axis
10959 .inputIndexes = {0},
10960 .operands = {{ // op1
10961 .channelQuant = {},
10962 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
10963 .dimensions = {2, 2, 5, 2},
10964 .isIgnored = false,
10965 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10966 .numberOfConsumers = 1,
10967 .scale = 0.0f,
10968 .type = TestOperandType::TENSOR_FLOAT16,
10969 .zeroPoint = 0
10970 }, { // param2
10971 .channelQuant = {},
10972 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
10973 .dimensions = {},
10974 .isIgnored = false,
10975 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10976 .numberOfConsumers = 1,
10977 .scale = 0.0f,
10978 .type = TestOperandType::FLOAT16,
10979 .zeroPoint = 0
10980 }, { // axis
10981 .channelQuant = {},
10982 .data = TestBuffer::createFromVector<int32_t>({2}),
10983 .dimensions = {},
10984 .isIgnored = false,
10985 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10986 .numberOfConsumers = 1,
10987 .scale = 0.0f,
10988 .type = TestOperandType::INT32,
10989 .zeroPoint = 0
10990 }, { // op2
10991 .channelQuant = {},
10992 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
10993 .dimensions = {2, 2, 5, 2},
10994 .isIgnored = false,
10995 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10996 .numberOfConsumers = 0,
10997 .scale = 0.0f,
10998 .type = TestOperandType::TENSOR_FLOAT16,
10999 .zeroPoint = 0
11000 }},
11001 .operations = {{
11002 .inputs = {0, 1, 2},
11003 .outputs = {3},
11004 .type = TestOperationType::SOFTMAX
11005 }},
11006 .outputIndexes = {3}
11007 },
11008 .minSupportedVersion = TestHalVersion::V1_2,
11009 .referenced = {}
11010 };
11011 return model;
11012 }
11013
11014 const auto dummy_test_model_axis_float16_dim4_axis2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2", get_test_model_axis_float16_dim4_axis2());
11015
11016 } // namespace generated_tests::softmax_v1_2
11017
11018 namespace generated_tests::softmax_v1_2 {
11019
get_test_model_axis_float16_dim4_axis2_all_inputs_as_internal()11020 const TestModel& get_test_model_axis_float16_dim4_axis2_all_inputs_as_internal() {
11021 static TestModel model = {
11022 .expectFailure = false,
11023 .expectedMultinomialDistributionTolerance = 0,
11024 .isRelaxed = false,
11025 .main = { // axis
11026 .inputIndexes = {4},
11027 .operands = {{ // op1
11028 .channelQuant = {},
11029 .data = TestBuffer::createFromVector<_Float16>({}),
11030 .dimensions = {2, 2, 5, 2},
11031 .isIgnored = false,
11032 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11033 .numberOfConsumers = 1,
11034 .scale = 0.0f,
11035 .type = TestOperandType::TENSOR_FLOAT16,
11036 .zeroPoint = 0
11037 }, { // param2
11038 .channelQuant = {},
11039 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11040 .dimensions = {},
11041 .isIgnored = false,
11042 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11043 .numberOfConsumers = 1,
11044 .scale = 0.0f,
11045 .type = TestOperandType::FLOAT16,
11046 .zeroPoint = 0
11047 }, { // axis
11048 .channelQuant = {},
11049 .data = TestBuffer::createFromVector<int32_t>({2}),
11050 .dimensions = {},
11051 .isIgnored = false,
11052 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11053 .numberOfConsumers = 1,
11054 .scale = 0.0f,
11055 .type = TestOperandType::INT32,
11056 .zeroPoint = 0
11057 }, { // op2
11058 .channelQuant = {},
11059 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
11060 .dimensions = {2, 2, 5, 2},
11061 .isIgnored = false,
11062 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11063 .numberOfConsumers = 0,
11064 .scale = 0.0f,
11065 .type = TestOperandType::TENSOR_FLOAT16,
11066 .zeroPoint = 0
11067 }, { // op1_new
11068 .channelQuant = {},
11069 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
11070 .dimensions = {2, 2, 5, 2},
11071 .isIgnored = false,
11072 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11073 .numberOfConsumers = 1,
11074 .scale = 0.0f,
11075 .type = TestOperandType::TENSOR_FLOAT16,
11076 .zeroPoint = 0
11077 }, { // placeholder68
11078 .channelQuant = {},
11079 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
11080 .dimensions = {1},
11081 .isIgnored = false,
11082 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11083 .numberOfConsumers = 1,
11084 .scale = 0.0f,
11085 .type = TestOperandType::TENSOR_FLOAT16,
11086 .zeroPoint = 0
11087 }, { // param86
11088 .channelQuant = {},
11089 .data = TestBuffer::createFromVector<int32_t>({0}),
11090 .dimensions = {},
11091 .isIgnored = false,
11092 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11093 .numberOfConsumers = 1,
11094 .scale = 0.0f,
11095 .type = TestOperandType::INT32,
11096 .zeroPoint = 0
11097 }},
11098 .operations = {{
11099 .inputs = {4, 5, 6},
11100 .outputs = {0},
11101 .type = TestOperationType::ADD
11102 }, {
11103 .inputs = {0, 1, 2},
11104 .outputs = {3},
11105 .type = TestOperationType::SOFTMAX
11106 }},
11107 .outputIndexes = {3}
11108 },
11109 .minSupportedVersion = TestHalVersion::V1_2,
11110 .referenced = {}
11111 };
11112 return model;
11113 }
11114
11115 const auto dummy_test_model_axis_float16_dim4_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis2_all_inputs_as_internal());
11116
11117 } // namespace generated_tests::softmax_v1_2
11118
11119 namespace generated_tests::softmax_v1_2 {
11120
get_test_model_axis_float16_dim4_axis2_neg()11121 const TestModel& get_test_model_axis_float16_dim4_axis2_neg() {
11122 static TestModel model = {
11123 .expectFailure = false,
11124 .expectedMultinomialDistributionTolerance = 0,
11125 .isRelaxed = false,
11126 .main = { // axis
11127 .inputIndexes = {0},
11128 .operands = {{ // op1
11129 .channelQuant = {},
11130 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
11131 .dimensions = {2, 2, 5, 2},
11132 .isIgnored = false,
11133 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11134 .numberOfConsumers = 1,
11135 .scale = 0.0f,
11136 .type = TestOperandType::TENSOR_FLOAT16,
11137 .zeroPoint = 0
11138 }, { // param2
11139 .channelQuant = {},
11140 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11141 .dimensions = {},
11142 .isIgnored = false,
11143 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11144 .numberOfConsumers = 1,
11145 .scale = 0.0f,
11146 .type = TestOperandType::FLOAT16,
11147 .zeroPoint = 0
11148 }, { // axis
11149 .channelQuant = {},
11150 .data = TestBuffer::createFromVector<int32_t>({-2}),
11151 .dimensions = {},
11152 .isIgnored = false,
11153 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11154 .numberOfConsumers = 1,
11155 .scale = 0.0f,
11156 .type = TestOperandType::INT32,
11157 .zeroPoint = 0
11158 }, { // op2
11159 .channelQuant = {},
11160 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
11161 .dimensions = {2, 2, 5, 2},
11162 .isIgnored = false,
11163 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11164 .numberOfConsumers = 0,
11165 .scale = 0.0f,
11166 .type = TestOperandType::TENSOR_FLOAT16,
11167 .zeroPoint = 0
11168 }},
11169 .operations = {{
11170 .inputs = {0, 1, 2},
11171 .outputs = {3},
11172 .type = TestOperationType::SOFTMAX
11173 }},
11174 .outputIndexes = {3}
11175 },
11176 .minSupportedVersion = TestHalVersion::V1_2,
11177 .referenced = {}
11178 };
11179 return model;
11180 }
11181
11182 const auto dummy_test_model_axis_float16_dim4_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2_neg", get_test_model_axis_float16_dim4_axis2_neg());
11183
11184 } // namespace generated_tests::softmax_v1_2
11185
11186 namespace generated_tests::softmax_v1_2 {
11187
get_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal()11188 const TestModel& get_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal() {
11189 static TestModel model = {
11190 .expectFailure = false,
11191 .expectedMultinomialDistributionTolerance = 0,
11192 .isRelaxed = false,
11193 .main = { // axis
11194 .inputIndexes = {4},
11195 .operands = {{ // op1
11196 .channelQuant = {},
11197 .data = TestBuffer::createFromVector<_Float16>({}),
11198 .dimensions = {2, 2, 5, 2},
11199 .isIgnored = false,
11200 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11201 .numberOfConsumers = 1,
11202 .scale = 0.0f,
11203 .type = TestOperandType::TENSOR_FLOAT16,
11204 .zeroPoint = 0
11205 }, { // param2
11206 .channelQuant = {},
11207 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11208 .dimensions = {},
11209 .isIgnored = false,
11210 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11211 .numberOfConsumers = 1,
11212 .scale = 0.0f,
11213 .type = TestOperandType::FLOAT16,
11214 .zeroPoint = 0
11215 }, { // axis
11216 .channelQuant = {},
11217 .data = TestBuffer::createFromVector<int32_t>({-2}),
11218 .dimensions = {},
11219 .isIgnored = false,
11220 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11221 .numberOfConsumers = 1,
11222 .scale = 0.0f,
11223 .type = TestOperandType::INT32,
11224 .zeroPoint = 0
11225 }, { // op2
11226 .channelQuant = {},
11227 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
11228 .dimensions = {2, 2, 5, 2},
11229 .isIgnored = false,
11230 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11231 .numberOfConsumers = 0,
11232 .scale = 0.0f,
11233 .type = TestOperandType::TENSOR_FLOAT16,
11234 .zeroPoint = 0
11235 }, { // op1_new
11236 .channelQuant = {},
11237 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
11238 .dimensions = {2, 2, 5, 2},
11239 .isIgnored = false,
11240 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11241 .numberOfConsumers = 1,
11242 .scale = 0.0f,
11243 .type = TestOperandType::TENSOR_FLOAT16,
11244 .zeroPoint = 0
11245 }, { // placeholder69
11246 .channelQuant = {},
11247 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
11248 .dimensions = {1},
11249 .isIgnored = false,
11250 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11251 .numberOfConsumers = 1,
11252 .scale = 0.0f,
11253 .type = TestOperandType::TENSOR_FLOAT16,
11254 .zeroPoint = 0
11255 }, { // param87
11256 .channelQuant = {},
11257 .data = TestBuffer::createFromVector<int32_t>({0}),
11258 .dimensions = {},
11259 .isIgnored = false,
11260 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11261 .numberOfConsumers = 1,
11262 .scale = 0.0f,
11263 .type = TestOperandType::INT32,
11264 .zeroPoint = 0
11265 }},
11266 .operations = {{
11267 .inputs = {4, 5, 6},
11268 .outputs = {0},
11269 .type = TestOperationType::ADD
11270 }, {
11271 .inputs = {0, 1, 2},
11272 .outputs = {3},
11273 .type = TestOperationType::SOFTMAX
11274 }},
11275 .outputIndexes = {3}
11276 },
11277 .minSupportedVersion = TestHalVersion::V1_2,
11278 .referenced = {}
11279 };
11280 return model;
11281 }
11282
11283 const auto dummy_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2_neg_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal());
11284
11285 } // namespace generated_tests::softmax_v1_2
11286
11287 namespace generated_tests::softmax_v1_2 {
11288
get_test_model_axis_float16_dim4_axis3()11289 const TestModel& get_test_model_axis_float16_dim4_axis3() {
11290 static TestModel model = {
11291 .expectFailure = false,
11292 .expectedMultinomialDistributionTolerance = 0,
11293 .isRelaxed = false,
11294 .main = { // axis
11295 .inputIndexes = {0},
11296 .operands = {{ // op1
11297 .channelQuant = {},
11298 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
11299 .dimensions = {2, 2, 2, 5},
11300 .isIgnored = false,
11301 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11302 .numberOfConsumers = 1,
11303 .scale = 0.0f,
11304 .type = TestOperandType::TENSOR_FLOAT16,
11305 .zeroPoint = 0
11306 }, { // param2
11307 .channelQuant = {},
11308 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11309 .dimensions = {},
11310 .isIgnored = false,
11311 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11312 .numberOfConsumers = 1,
11313 .scale = 0.0f,
11314 .type = TestOperandType::FLOAT16,
11315 .zeroPoint = 0
11316 }, { // axis
11317 .channelQuant = {},
11318 .data = TestBuffer::createFromVector<int32_t>({3}),
11319 .dimensions = {},
11320 .isIgnored = false,
11321 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11322 .numberOfConsumers = 1,
11323 .scale = 0.0f,
11324 .type = TestOperandType::INT32,
11325 .zeroPoint = 0
11326 }, { // op2
11327 .channelQuant = {},
11328 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
11329 .dimensions = {2, 2, 2, 5},
11330 .isIgnored = false,
11331 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11332 .numberOfConsumers = 0,
11333 .scale = 0.0f,
11334 .type = TestOperandType::TENSOR_FLOAT16,
11335 .zeroPoint = 0
11336 }},
11337 .operations = {{
11338 .inputs = {0, 1, 2},
11339 .outputs = {3},
11340 .type = TestOperationType::SOFTMAX
11341 }},
11342 .outputIndexes = {3}
11343 },
11344 .minSupportedVersion = TestHalVersion::V1_2,
11345 .referenced = {}
11346 };
11347 return model;
11348 }
11349
11350 const auto dummy_test_model_axis_float16_dim4_axis3 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3", get_test_model_axis_float16_dim4_axis3());
11351
11352 } // namespace generated_tests::softmax_v1_2
11353
11354 namespace generated_tests::softmax_v1_2 {
11355
get_test_model_axis_float16_dim4_axis3_all_inputs_as_internal()11356 const TestModel& get_test_model_axis_float16_dim4_axis3_all_inputs_as_internal() {
11357 static TestModel model = {
11358 .expectFailure = false,
11359 .expectedMultinomialDistributionTolerance = 0,
11360 .isRelaxed = false,
11361 .main = { // axis
11362 .inputIndexes = {4},
11363 .operands = {{ // op1
11364 .channelQuant = {},
11365 .data = TestBuffer::createFromVector<_Float16>({}),
11366 .dimensions = {2, 2, 2, 5},
11367 .isIgnored = false,
11368 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11369 .numberOfConsumers = 1,
11370 .scale = 0.0f,
11371 .type = TestOperandType::TENSOR_FLOAT16,
11372 .zeroPoint = 0
11373 }, { // param2
11374 .channelQuant = {},
11375 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11376 .dimensions = {},
11377 .isIgnored = false,
11378 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11379 .numberOfConsumers = 1,
11380 .scale = 0.0f,
11381 .type = TestOperandType::FLOAT16,
11382 .zeroPoint = 0
11383 }, { // axis
11384 .channelQuant = {},
11385 .data = TestBuffer::createFromVector<int32_t>({3}),
11386 .dimensions = {},
11387 .isIgnored = false,
11388 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11389 .numberOfConsumers = 1,
11390 .scale = 0.0f,
11391 .type = TestOperandType::INT32,
11392 .zeroPoint = 0
11393 }, { // op2
11394 .channelQuant = {},
11395 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
11396 .dimensions = {2, 2, 2, 5},
11397 .isIgnored = false,
11398 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11399 .numberOfConsumers = 0,
11400 .scale = 0.0f,
11401 .type = TestOperandType::TENSOR_FLOAT16,
11402 .zeroPoint = 0
11403 }, { // op1_new
11404 .channelQuant = {},
11405 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
11406 .dimensions = {2, 2, 2, 5},
11407 .isIgnored = false,
11408 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11409 .numberOfConsumers = 1,
11410 .scale = 0.0f,
11411 .type = TestOperandType::TENSOR_FLOAT16,
11412 .zeroPoint = 0
11413 }, { // placeholder70
11414 .channelQuant = {},
11415 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
11416 .dimensions = {1},
11417 .isIgnored = false,
11418 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11419 .numberOfConsumers = 1,
11420 .scale = 0.0f,
11421 .type = TestOperandType::TENSOR_FLOAT16,
11422 .zeroPoint = 0
11423 }, { // param88
11424 .channelQuant = {},
11425 .data = TestBuffer::createFromVector<int32_t>({0}),
11426 .dimensions = {},
11427 .isIgnored = false,
11428 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11429 .numberOfConsumers = 1,
11430 .scale = 0.0f,
11431 .type = TestOperandType::INT32,
11432 .zeroPoint = 0
11433 }},
11434 .operations = {{
11435 .inputs = {4, 5, 6},
11436 .outputs = {0},
11437 .type = TestOperationType::ADD
11438 }, {
11439 .inputs = {0, 1, 2},
11440 .outputs = {3},
11441 .type = TestOperationType::SOFTMAX
11442 }},
11443 .outputIndexes = {3}
11444 },
11445 .minSupportedVersion = TestHalVersion::V1_2,
11446 .referenced = {}
11447 };
11448 return model;
11449 }
11450
11451 const auto dummy_test_model_axis_float16_dim4_axis3_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis3_all_inputs_as_internal());
11452
11453 } // namespace generated_tests::softmax_v1_2
11454
11455 namespace generated_tests::softmax_v1_2 {
11456
get_test_model_axis_float16_dim4_axis3_neg()11457 const TestModel& get_test_model_axis_float16_dim4_axis3_neg() {
11458 static TestModel model = {
11459 .expectFailure = false,
11460 .expectedMultinomialDistributionTolerance = 0,
11461 .isRelaxed = false,
11462 .main = { // axis
11463 .inputIndexes = {0},
11464 .operands = {{ // op1
11465 .channelQuant = {},
11466 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
11467 .dimensions = {2, 2, 2, 5},
11468 .isIgnored = false,
11469 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11470 .numberOfConsumers = 1,
11471 .scale = 0.0f,
11472 .type = TestOperandType::TENSOR_FLOAT16,
11473 .zeroPoint = 0
11474 }, { // param2
11475 .channelQuant = {},
11476 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11477 .dimensions = {},
11478 .isIgnored = false,
11479 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11480 .numberOfConsumers = 1,
11481 .scale = 0.0f,
11482 .type = TestOperandType::FLOAT16,
11483 .zeroPoint = 0
11484 }, { // axis
11485 .channelQuant = {},
11486 .data = TestBuffer::createFromVector<int32_t>({-1}),
11487 .dimensions = {},
11488 .isIgnored = false,
11489 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11490 .numberOfConsumers = 1,
11491 .scale = 0.0f,
11492 .type = TestOperandType::INT32,
11493 .zeroPoint = 0
11494 }, { // op2
11495 .channelQuant = {},
11496 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
11497 .dimensions = {2, 2, 2, 5},
11498 .isIgnored = false,
11499 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11500 .numberOfConsumers = 0,
11501 .scale = 0.0f,
11502 .type = TestOperandType::TENSOR_FLOAT16,
11503 .zeroPoint = 0
11504 }},
11505 .operations = {{
11506 .inputs = {0, 1, 2},
11507 .outputs = {3},
11508 .type = TestOperationType::SOFTMAX
11509 }},
11510 .outputIndexes = {3}
11511 },
11512 .minSupportedVersion = TestHalVersion::V1_2,
11513 .referenced = {}
11514 };
11515 return model;
11516 }
11517
11518 const auto dummy_test_model_axis_float16_dim4_axis3_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3_neg", get_test_model_axis_float16_dim4_axis3_neg());
11519
11520 } // namespace generated_tests::softmax_v1_2
11521
11522 namespace generated_tests::softmax_v1_2 {
11523
get_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal()11524 const TestModel& get_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal() {
11525 static TestModel model = {
11526 .expectFailure = false,
11527 .expectedMultinomialDistributionTolerance = 0,
11528 .isRelaxed = false,
11529 .main = { // axis
11530 .inputIndexes = {4},
11531 .operands = {{ // op1
11532 .channelQuant = {},
11533 .data = TestBuffer::createFromVector<_Float16>({}),
11534 .dimensions = {2, 2, 2, 5},
11535 .isIgnored = false,
11536 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11537 .numberOfConsumers = 1,
11538 .scale = 0.0f,
11539 .type = TestOperandType::TENSOR_FLOAT16,
11540 .zeroPoint = 0
11541 }, { // param2
11542 .channelQuant = {},
11543 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11544 .dimensions = {},
11545 .isIgnored = false,
11546 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11547 .numberOfConsumers = 1,
11548 .scale = 0.0f,
11549 .type = TestOperandType::FLOAT16,
11550 .zeroPoint = 0
11551 }, { // axis
11552 .channelQuant = {},
11553 .data = TestBuffer::createFromVector<int32_t>({-1}),
11554 .dimensions = {},
11555 .isIgnored = false,
11556 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11557 .numberOfConsumers = 1,
11558 .scale = 0.0f,
11559 .type = TestOperandType::INT32,
11560 .zeroPoint = 0
11561 }, { // op2
11562 .channelQuant = {},
11563 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
11564 .dimensions = {2, 2, 2, 5},
11565 .isIgnored = false,
11566 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11567 .numberOfConsumers = 0,
11568 .scale = 0.0f,
11569 .type = TestOperandType::TENSOR_FLOAT16,
11570 .zeroPoint = 0
11571 }, { // op1_new
11572 .channelQuant = {},
11573 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
11574 .dimensions = {2, 2, 2, 5},
11575 .isIgnored = false,
11576 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11577 .numberOfConsumers = 1,
11578 .scale = 0.0f,
11579 .type = TestOperandType::TENSOR_FLOAT16,
11580 .zeroPoint = 0
11581 }, { // placeholder71
11582 .channelQuant = {},
11583 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
11584 .dimensions = {1},
11585 .isIgnored = false,
11586 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11587 .numberOfConsumers = 1,
11588 .scale = 0.0f,
11589 .type = TestOperandType::TENSOR_FLOAT16,
11590 .zeroPoint = 0
11591 }, { // param89
11592 .channelQuant = {},
11593 .data = TestBuffer::createFromVector<int32_t>({0}),
11594 .dimensions = {},
11595 .isIgnored = false,
11596 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11597 .numberOfConsumers = 1,
11598 .scale = 0.0f,
11599 .type = TestOperandType::INT32,
11600 .zeroPoint = 0
11601 }},
11602 .operations = {{
11603 .inputs = {4, 5, 6},
11604 .outputs = {0},
11605 .type = TestOperationType::ADD
11606 }, {
11607 .inputs = {0, 1, 2},
11608 .outputs = {3},
11609 .type = TestOperationType::SOFTMAX
11610 }},
11611 .outputIndexes = {3}
11612 },
11613 .minSupportedVersion = TestHalVersion::V1_2,
11614 .referenced = {}
11615 };
11616 return model;
11617 }
11618
11619 const auto dummy_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3_neg_all_inputs_as_internal", get_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal());
11620
11621 } // namespace generated_tests::softmax_v1_2
11622
11623 namespace generated_tests::softmax_v1_2 {
11624
get_test_model_axis_float16_dim3_axis0()11625 const TestModel& get_test_model_axis_float16_dim3_axis0() {
11626 static TestModel model = {
11627 .expectFailure = false,
11628 .expectedMultinomialDistributionTolerance = 0,
11629 .isRelaxed = false,
11630 .main = { // axis
11631 .inputIndexes = {0},
11632 .operands = {{ // op1
11633 .channelQuant = {},
11634 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
11635 .dimensions = {5, 2, 2},
11636 .isIgnored = false,
11637 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11638 .numberOfConsumers = 1,
11639 .scale = 0.0f,
11640 .type = TestOperandType::TENSOR_FLOAT16,
11641 .zeroPoint = 0
11642 }, { // param2
11643 .channelQuant = {},
11644 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11645 .dimensions = {},
11646 .isIgnored = false,
11647 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11648 .numberOfConsumers = 1,
11649 .scale = 0.0f,
11650 .type = TestOperandType::FLOAT16,
11651 .zeroPoint = 0
11652 }, { // axis
11653 .channelQuant = {},
11654 .data = TestBuffer::createFromVector<int32_t>({0}),
11655 .dimensions = {},
11656 .isIgnored = false,
11657 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11658 .numberOfConsumers = 1,
11659 .scale = 0.0f,
11660 .type = TestOperandType::INT32,
11661 .zeroPoint = 0
11662 }, { // op2
11663 .channelQuant = {},
11664 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
11665 .dimensions = {5, 2, 2},
11666 .isIgnored = false,
11667 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11668 .numberOfConsumers = 0,
11669 .scale = 0.0f,
11670 .type = TestOperandType::TENSOR_FLOAT16,
11671 .zeroPoint = 0
11672 }},
11673 .operations = {{
11674 .inputs = {0, 1, 2},
11675 .outputs = {3},
11676 .type = TestOperationType::SOFTMAX
11677 }},
11678 .outputIndexes = {3}
11679 },
11680 .minSupportedVersion = TestHalVersion::V1_2,
11681 .referenced = {}
11682 };
11683 return model;
11684 }
11685
11686 const auto dummy_test_model_axis_float16_dim3_axis0 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0", get_test_model_axis_float16_dim3_axis0());
11687
11688 } // namespace generated_tests::softmax_v1_2
11689
11690 namespace generated_tests::softmax_v1_2 {
11691
get_test_model_axis_float16_dim3_axis0_all_inputs_as_internal()11692 const TestModel& get_test_model_axis_float16_dim3_axis0_all_inputs_as_internal() {
11693 static TestModel model = {
11694 .expectFailure = false,
11695 .expectedMultinomialDistributionTolerance = 0,
11696 .isRelaxed = false,
11697 .main = { // axis
11698 .inputIndexes = {4},
11699 .operands = {{ // op1
11700 .channelQuant = {},
11701 .data = TestBuffer::createFromVector<_Float16>({}),
11702 .dimensions = {5, 2, 2},
11703 .isIgnored = false,
11704 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11705 .numberOfConsumers = 1,
11706 .scale = 0.0f,
11707 .type = TestOperandType::TENSOR_FLOAT16,
11708 .zeroPoint = 0
11709 }, { // param2
11710 .channelQuant = {},
11711 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11712 .dimensions = {},
11713 .isIgnored = false,
11714 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11715 .numberOfConsumers = 1,
11716 .scale = 0.0f,
11717 .type = TestOperandType::FLOAT16,
11718 .zeroPoint = 0
11719 }, { // axis
11720 .channelQuant = {},
11721 .data = TestBuffer::createFromVector<int32_t>({0}),
11722 .dimensions = {},
11723 .isIgnored = false,
11724 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11725 .numberOfConsumers = 1,
11726 .scale = 0.0f,
11727 .type = TestOperandType::INT32,
11728 .zeroPoint = 0
11729 }, { // op2
11730 .channelQuant = {},
11731 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
11732 .dimensions = {5, 2, 2},
11733 .isIgnored = false,
11734 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11735 .numberOfConsumers = 0,
11736 .scale = 0.0f,
11737 .type = TestOperandType::TENSOR_FLOAT16,
11738 .zeroPoint = 0
11739 }, { // op1_new
11740 .channelQuant = {},
11741 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
11742 .dimensions = {5, 2, 2},
11743 .isIgnored = false,
11744 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11745 .numberOfConsumers = 1,
11746 .scale = 0.0f,
11747 .type = TestOperandType::TENSOR_FLOAT16,
11748 .zeroPoint = 0
11749 }, { // placeholder72
11750 .channelQuant = {},
11751 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
11752 .dimensions = {1},
11753 .isIgnored = false,
11754 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11755 .numberOfConsumers = 1,
11756 .scale = 0.0f,
11757 .type = TestOperandType::TENSOR_FLOAT16,
11758 .zeroPoint = 0
11759 }, { // param90
11760 .channelQuant = {},
11761 .data = TestBuffer::createFromVector<int32_t>({0}),
11762 .dimensions = {},
11763 .isIgnored = false,
11764 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11765 .numberOfConsumers = 1,
11766 .scale = 0.0f,
11767 .type = TestOperandType::INT32,
11768 .zeroPoint = 0
11769 }},
11770 .operations = {{
11771 .inputs = {4, 5, 6},
11772 .outputs = {0},
11773 .type = TestOperationType::ADD
11774 }, {
11775 .inputs = {0, 1, 2},
11776 .outputs = {3},
11777 .type = TestOperationType::SOFTMAX
11778 }},
11779 .outputIndexes = {3}
11780 },
11781 .minSupportedVersion = TestHalVersion::V1_2,
11782 .referenced = {}
11783 };
11784 return model;
11785 }
11786
11787 const auto dummy_test_model_axis_float16_dim3_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0_all_inputs_as_internal", get_test_model_axis_float16_dim3_axis0_all_inputs_as_internal());
11788
11789 } // namespace generated_tests::softmax_v1_2
11790
11791 namespace generated_tests::softmax_v1_2 {
11792
get_test_model_axis_float16_dim3_axis0_neg()11793 const TestModel& get_test_model_axis_float16_dim3_axis0_neg() {
11794 static TestModel model = {
11795 .expectFailure = false,
11796 .expectedMultinomialDistributionTolerance = 0,
11797 .isRelaxed = false,
11798 .main = { // axis
11799 .inputIndexes = {0},
11800 .operands = {{ // op1
11801 .channelQuant = {},
11802 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
11803 .dimensions = {5, 2, 2},
11804 .isIgnored = false,
11805 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11806 .numberOfConsumers = 1,
11807 .scale = 0.0f,
11808 .type = TestOperandType::TENSOR_FLOAT16,
11809 .zeroPoint = 0
11810 }, { // param2
11811 .channelQuant = {},
11812 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11813 .dimensions = {},
11814 .isIgnored = false,
11815 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11816 .numberOfConsumers = 1,
11817 .scale = 0.0f,
11818 .type = TestOperandType::FLOAT16,
11819 .zeroPoint = 0
11820 }, { // axis
11821 .channelQuant = {},
11822 .data = TestBuffer::createFromVector<int32_t>({-3}),
11823 .dimensions = {},
11824 .isIgnored = false,
11825 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11826 .numberOfConsumers = 1,
11827 .scale = 0.0f,
11828 .type = TestOperandType::INT32,
11829 .zeroPoint = 0
11830 }, { // op2
11831 .channelQuant = {},
11832 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
11833 .dimensions = {5, 2, 2},
11834 .isIgnored = false,
11835 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11836 .numberOfConsumers = 0,
11837 .scale = 0.0f,
11838 .type = TestOperandType::TENSOR_FLOAT16,
11839 .zeroPoint = 0
11840 }},
11841 .operations = {{
11842 .inputs = {0, 1, 2},
11843 .outputs = {3},
11844 .type = TestOperationType::SOFTMAX
11845 }},
11846 .outputIndexes = {3}
11847 },
11848 .minSupportedVersion = TestHalVersion::V1_2,
11849 .referenced = {}
11850 };
11851 return model;
11852 }
11853
11854 const auto dummy_test_model_axis_float16_dim3_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0_neg", get_test_model_axis_float16_dim3_axis0_neg());
11855
11856 } // namespace generated_tests::softmax_v1_2
11857
11858 namespace generated_tests::softmax_v1_2 {
11859
get_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal()11860 const TestModel& get_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal() {
11861 static TestModel model = {
11862 .expectFailure = false,
11863 .expectedMultinomialDistributionTolerance = 0,
11864 .isRelaxed = false,
11865 .main = { // axis
11866 .inputIndexes = {4},
11867 .operands = {{ // op1
11868 .channelQuant = {},
11869 .data = TestBuffer::createFromVector<_Float16>({}),
11870 .dimensions = {5, 2, 2},
11871 .isIgnored = false,
11872 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11873 .numberOfConsumers = 1,
11874 .scale = 0.0f,
11875 .type = TestOperandType::TENSOR_FLOAT16,
11876 .zeroPoint = 0
11877 }, { // param2
11878 .channelQuant = {},
11879 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11880 .dimensions = {},
11881 .isIgnored = false,
11882 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11883 .numberOfConsumers = 1,
11884 .scale = 0.0f,
11885 .type = TestOperandType::FLOAT16,
11886 .zeroPoint = 0
11887 }, { // axis
11888 .channelQuant = {},
11889 .data = TestBuffer::createFromVector<int32_t>({-3}),
11890 .dimensions = {},
11891 .isIgnored = false,
11892 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11893 .numberOfConsumers = 1,
11894 .scale = 0.0f,
11895 .type = TestOperandType::INT32,
11896 .zeroPoint = 0
11897 }, { // op2
11898 .channelQuant = {},
11899 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
11900 .dimensions = {5, 2, 2},
11901 .isIgnored = false,
11902 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11903 .numberOfConsumers = 0,
11904 .scale = 0.0f,
11905 .type = TestOperandType::TENSOR_FLOAT16,
11906 .zeroPoint = 0
11907 }, { // op1_new
11908 .channelQuant = {},
11909 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 17.0f, -1.0f, 16.0f, -2.0f, 16.0f, -2.0f, 15.0f, -3.0f, 15.0f, -3.0f, 14.0f, -4.0f, 14.0f, -4.0f, 1.0f, -17.0f, 1.0f, -17.0f}),
11910 .dimensions = {5, 2, 2},
11911 .isIgnored = false,
11912 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11913 .numberOfConsumers = 1,
11914 .scale = 0.0f,
11915 .type = TestOperandType::TENSOR_FLOAT16,
11916 .zeroPoint = 0
11917 }, { // placeholder73
11918 .channelQuant = {},
11919 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
11920 .dimensions = {1},
11921 .isIgnored = false,
11922 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11923 .numberOfConsumers = 1,
11924 .scale = 0.0f,
11925 .type = TestOperandType::TENSOR_FLOAT16,
11926 .zeroPoint = 0
11927 }, { // param91
11928 .channelQuant = {},
11929 .data = TestBuffer::createFromVector<int32_t>({0}),
11930 .dimensions = {},
11931 .isIgnored = false,
11932 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11933 .numberOfConsumers = 1,
11934 .scale = 0.0f,
11935 .type = TestOperandType::INT32,
11936 .zeroPoint = 0
11937 }},
11938 .operations = {{
11939 .inputs = {4, 5, 6},
11940 .outputs = {0},
11941 .type = TestOperationType::ADD
11942 }, {
11943 .inputs = {0, 1, 2},
11944 .outputs = {3},
11945 .type = TestOperationType::SOFTMAX
11946 }},
11947 .outputIndexes = {3}
11948 },
11949 .minSupportedVersion = TestHalVersion::V1_2,
11950 .referenced = {}
11951 };
11952 return model;
11953 }
11954
11955 const auto dummy_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0_neg_all_inputs_as_internal", get_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal());
11956
11957 } // namespace generated_tests::softmax_v1_2
11958
11959 namespace generated_tests::softmax_v1_2 {
11960
get_test_model_axis_float16_dim3_axis1()11961 const TestModel& get_test_model_axis_float16_dim3_axis1() {
11962 static TestModel model = {
11963 .expectFailure = false,
11964 .expectedMultinomialDistributionTolerance = 0,
11965 .isRelaxed = false,
11966 .main = { // axis
11967 .inputIndexes = {0},
11968 .operands = {{ // op1
11969 .channelQuant = {},
11970 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
11971 .dimensions = {2, 5, 2},
11972 .isIgnored = false,
11973 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11974 .numberOfConsumers = 1,
11975 .scale = 0.0f,
11976 .type = TestOperandType::TENSOR_FLOAT16,
11977 .zeroPoint = 0
11978 }, { // param2
11979 .channelQuant = {},
11980 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11981 .dimensions = {},
11982 .isIgnored = false,
11983 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11984 .numberOfConsumers = 1,
11985 .scale = 0.0f,
11986 .type = TestOperandType::FLOAT16,
11987 .zeroPoint = 0
11988 }, { // axis
11989 .channelQuant = {},
11990 .data = TestBuffer::createFromVector<int32_t>({1}),
11991 .dimensions = {},
11992 .isIgnored = false,
11993 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11994 .numberOfConsumers = 1,
11995 .scale = 0.0f,
11996 .type = TestOperandType::INT32,
11997 .zeroPoint = 0
11998 }, { // op2
11999 .channelQuant = {},
12000 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12001 .dimensions = {2, 5, 2},
12002 .isIgnored = false,
12003 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12004 .numberOfConsumers = 0,
12005 .scale = 0.0f,
12006 .type = TestOperandType::TENSOR_FLOAT16,
12007 .zeroPoint = 0
12008 }},
12009 .operations = {{
12010 .inputs = {0, 1, 2},
12011 .outputs = {3},
12012 .type = TestOperationType::SOFTMAX
12013 }},
12014 .outputIndexes = {3}
12015 },
12016 .minSupportedVersion = TestHalVersion::V1_2,
12017 .referenced = {}
12018 };
12019 return model;
12020 }
12021
12022 const auto dummy_test_model_axis_float16_dim3_axis1 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1", get_test_model_axis_float16_dim3_axis1());
12023
12024 } // namespace generated_tests::softmax_v1_2
12025
12026 namespace generated_tests::softmax_v1_2 {
12027
get_test_model_axis_float16_dim3_axis1_all_inputs_as_internal()12028 const TestModel& get_test_model_axis_float16_dim3_axis1_all_inputs_as_internal() {
12029 static TestModel model = {
12030 .expectFailure = false,
12031 .expectedMultinomialDistributionTolerance = 0,
12032 .isRelaxed = false,
12033 .main = { // axis
12034 .inputIndexes = {4},
12035 .operands = {{ // op1
12036 .channelQuant = {},
12037 .data = TestBuffer::createFromVector<_Float16>({}),
12038 .dimensions = {2, 5, 2},
12039 .isIgnored = false,
12040 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
12041 .numberOfConsumers = 1,
12042 .scale = 0.0f,
12043 .type = TestOperandType::TENSOR_FLOAT16,
12044 .zeroPoint = 0
12045 }, { // param2
12046 .channelQuant = {},
12047 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12048 .dimensions = {},
12049 .isIgnored = false,
12050 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12051 .numberOfConsumers = 1,
12052 .scale = 0.0f,
12053 .type = TestOperandType::FLOAT16,
12054 .zeroPoint = 0
12055 }, { // axis
12056 .channelQuant = {},
12057 .data = TestBuffer::createFromVector<int32_t>({1}),
12058 .dimensions = {},
12059 .isIgnored = false,
12060 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12061 .numberOfConsumers = 1,
12062 .scale = 0.0f,
12063 .type = TestOperandType::INT32,
12064 .zeroPoint = 0
12065 }, { // op2
12066 .channelQuant = {},
12067 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12068 .dimensions = {2, 5, 2},
12069 .isIgnored = false,
12070 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12071 .numberOfConsumers = 0,
12072 .scale = 0.0f,
12073 .type = TestOperandType::TENSOR_FLOAT16,
12074 .zeroPoint = 0
12075 }, { // op1_new
12076 .channelQuant = {},
12077 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
12078 .dimensions = {2, 5, 2},
12079 .isIgnored = false,
12080 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12081 .numberOfConsumers = 1,
12082 .scale = 0.0f,
12083 .type = TestOperandType::TENSOR_FLOAT16,
12084 .zeroPoint = 0
12085 }, { // placeholder74
12086 .channelQuant = {},
12087 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
12088 .dimensions = {1},
12089 .isIgnored = false,
12090 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12091 .numberOfConsumers = 1,
12092 .scale = 0.0f,
12093 .type = TestOperandType::TENSOR_FLOAT16,
12094 .zeroPoint = 0
12095 }, { // param92
12096 .channelQuant = {},
12097 .data = TestBuffer::createFromVector<int32_t>({0}),
12098 .dimensions = {},
12099 .isIgnored = false,
12100 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12101 .numberOfConsumers = 1,
12102 .scale = 0.0f,
12103 .type = TestOperandType::INT32,
12104 .zeroPoint = 0
12105 }},
12106 .operations = {{
12107 .inputs = {4, 5, 6},
12108 .outputs = {0},
12109 .type = TestOperationType::ADD
12110 }, {
12111 .inputs = {0, 1, 2},
12112 .outputs = {3},
12113 .type = TestOperationType::SOFTMAX
12114 }},
12115 .outputIndexes = {3}
12116 },
12117 .minSupportedVersion = TestHalVersion::V1_2,
12118 .referenced = {}
12119 };
12120 return model;
12121 }
12122
12123 const auto dummy_test_model_axis_float16_dim3_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1_all_inputs_as_internal", get_test_model_axis_float16_dim3_axis1_all_inputs_as_internal());
12124
12125 } // namespace generated_tests::softmax_v1_2
12126
12127 namespace generated_tests::softmax_v1_2 {
12128
get_test_model_axis_float16_dim3_axis1_neg()12129 const TestModel& get_test_model_axis_float16_dim3_axis1_neg() {
12130 static TestModel model = {
12131 .expectFailure = false,
12132 .expectedMultinomialDistributionTolerance = 0,
12133 .isRelaxed = false,
12134 .main = { // axis
12135 .inputIndexes = {0},
12136 .operands = {{ // op1
12137 .channelQuant = {},
12138 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
12139 .dimensions = {2, 5, 2},
12140 .isIgnored = false,
12141 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12142 .numberOfConsumers = 1,
12143 .scale = 0.0f,
12144 .type = TestOperandType::TENSOR_FLOAT16,
12145 .zeroPoint = 0
12146 }, { // param2
12147 .channelQuant = {},
12148 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12149 .dimensions = {},
12150 .isIgnored = false,
12151 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12152 .numberOfConsumers = 1,
12153 .scale = 0.0f,
12154 .type = TestOperandType::FLOAT16,
12155 .zeroPoint = 0
12156 }, { // axis
12157 .channelQuant = {},
12158 .data = TestBuffer::createFromVector<int32_t>({-2}),
12159 .dimensions = {},
12160 .isIgnored = false,
12161 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12162 .numberOfConsumers = 1,
12163 .scale = 0.0f,
12164 .type = TestOperandType::INT32,
12165 .zeroPoint = 0
12166 }, { // op2
12167 .channelQuant = {},
12168 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12169 .dimensions = {2, 5, 2},
12170 .isIgnored = false,
12171 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12172 .numberOfConsumers = 0,
12173 .scale = 0.0f,
12174 .type = TestOperandType::TENSOR_FLOAT16,
12175 .zeroPoint = 0
12176 }},
12177 .operations = {{
12178 .inputs = {0, 1, 2},
12179 .outputs = {3},
12180 .type = TestOperationType::SOFTMAX
12181 }},
12182 .outputIndexes = {3}
12183 },
12184 .minSupportedVersion = TestHalVersion::V1_2,
12185 .referenced = {}
12186 };
12187 return model;
12188 }
12189
12190 const auto dummy_test_model_axis_float16_dim3_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1_neg", get_test_model_axis_float16_dim3_axis1_neg());
12191
12192 } // namespace generated_tests::softmax_v1_2
12193
12194 namespace generated_tests::softmax_v1_2 {
12195
get_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal()12196 const TestModel& get_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal() {
12197 static TestModel model = {
12198 .expectFailure = false,
12199 .expectedMultinomialDistributionTolerance = 0,
12200 .isRelaxed = false,
12201 .main = { // axis
12202 .inputIndexes = {4},
12203 .operands = {{ // op1
12204 .channelQuant = {},
12205 .data = TestBuffer::createFromVector<_Float16>({}),
12206 .dimensions = {2, 5, 2},
12207 .isIgnored = false,
12208 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
12209 .numberOfConsumers = 1,
12210 .scale = 0.0f,
12211 .type = TestOperandType::TENSOR_FLOAT16,
12212 .zeroPoint = 0
12213 }, { // param2
12214 .channelQuant = {},
12215 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12216 .dimensions = {},
12217 .isIgnored = false,
12218 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12219 .numberOfConsumers = 1,
12220 .scale = 0.0f,
12221 .type = TestOperandType::FLOAT16,
12222 .zeroPoint = 0
12223 }, { // axis
12224 .channelQuant = {},
12225 .data = TestBuffer::createFromVector<int32_t>({-2}),
12226 .dimensions = {},
12227 .isIgnored = false,
12228 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12229 .numberOfConsumers = 1,
12230 .scale = 0.0f,
12231 .type = TestOperandType::INT32,
12232 .zeroPoint = 0
12233 }, { // op2
12234 .channelQuant = {},
12235 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f, 0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12236 .dimensions = {2, 5, 2},
12237 .isIgnored = false,
12238 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12239 .numberOfConsumers = 0,
12240 .scale = 0.0f,
12241 .type = TestOperandType::TENSOR_FLOAT16,
12242 .zeroPoint = 0
12243 }, { // op1_new
12244 .channelQuant = {},
12245 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f, 17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
12246 .dimensions = {2, 5, 2},
12247 .isIgnored = false,
12248 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12249 .numberOfConsumers = 1,
12250 .scale = 0.0f,
12251 .type = TestOperandType::TENSOR_FLOAT16,
12252 .zeroPoint = 0
12253 }, { // placeholder75
12254 .channelQuant = {},
12255 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
12256 .dimensions = {1},
12257 .isIgnored = false,
12258 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12259 .numberOfConsumers = 1,
12260 .scale = 0.0f,
12261 .type = TestOperandType::TENSOR_FLOAT16,
12262 .zeroPoint = 0
12263 }, { // param93
12264 .channelQuant = {},
12265 .data = TestBuffer::createFromVector<int32_t>({0}),
12266 .dimensions = {},
12267 .isIgnored = false,
12268 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12269 .numberOfConsumers = 1,
12270 .scale = 0.0f,
12271 .type = TestOperandType::INT32,
12272 .zeroPoint = 0
12273 }},
12274 .operations = {{
12275 .inputs = {4, 5, 6},
12276 .outputs = {0},
12277 .type = TestOperationType::ADD
12278 }, {
12279 .inputs = {0, 1, 2},
12280 .outputs = {3},
12281 .type = TestOperationType::SOFTMAX
12282 }},
12283 .outputIndexes = {3}
12284 },
12285 .minSupportedVersion = TestHalVersion::V1_2,
12286 .referenced = {}
12287 };
12288 return model;
12289 }
12290
12291 const auto dummy_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1_neg_all_inputs_as_internal", get_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal());
12292
12293 } // namespace generated_tests::softmax_v1_2
12294
12295 namespace generated_tests::softmax_v1_2 {
12296
get_test_model_axis_float16_dim3_axis2()12297 const TestModel& get_test_model_axis_float16_dim3_axis2() {
12298 static TestModel model = {
12299 .expectFailure = false,
12300 .expectedMultinomialDistributionTolerance = 0,
12301 .isRelaxed = false,
12302 .main = { // axis
12303 .inputIndexes = {0},
12304 .operands = {{ // op1
12305 .channelQuant = {},
12306 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
12307 .dimensions = {2, 2, 5},
12308 .isIgnored = false,
12309 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12310 .numberOfConsumers = 1,
12311 .scale = 0.0f,
12312 .type = TestOperandType::TENSOR_FLOAT16,
12313 .zeroPoint = 0
12314 }, { // param2
12315 .channelQuant = {},
12316 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12317 .dimensions = {},
12318 .isIgnored = false,
12319 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12320 .numberOfConsumers = 1,
12321 .scale = 0.0f,
12322 .type = TestOperandType::FLOAT16,
12323 .zeroPoint = 0
12324 }, { // axis
12325 .channelQuant = {},
12326 .data = TestBuffer::createFromVector<int32_t>({2}),
12327 .dimensions = {},
12328 .isIgnored = false,
12329 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12330 .numberOfConsumers = 1,
12331 .scale = 0.0f,
12332 .type = TestOperandType::INT32,
12333 .zeroPoint = 0
12334 }, { // op2
12335 .channelQuant = {},
12336 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
12337 .dimensions = {2, 2, 5},
12338 .isIgnored = false,
12339 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12340 .numberOfConsumers = 0,
12341 .scale = 0.0f,
12342 .type = TestOperandType::TENSOR_FLOAT16,
12343 .zeroPoint = 0
12344 }},
12345 .operations = {{
12346 .inputs = {0, 1, 2},
12347 .outputs = {3},
12348 .type = TestOperationType::SOFTMAX
12349 }},
12350 .outputIndexes = {3}
12351 },
12352 .minSupportedVersion = TestHalVersion::V1_2,
12353 .referenced = {}
12354 };
12355 return model;
12356 }
12357
12358 const auto dummy_test_model_axis_float16_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2", get_test_model_axis_float16_dim3_axis2());
12359
12360 } // namespace generated_tests::softmax_v1_2
12361
12362 namespace generated_tests::softmax_v1_2 {
12363
get_test_model_axis_float16_dim3_axis2_all_inputs_as_internal()12364 const TestModel& get_test_model_axis_float16_dim3_axis2_all_inputs_as_internal() {
12365 static TestModel model = {
12366 .expectFailure = false,
12367 .expectedMultinomialDistributionTolerance = 0,
12368 .isRelaxed = false,
12369 .main = { // axis
12370 .inputIndexes = {4},
12371 .operands = {{ // op1
12372 .channelQuant = {},
12373 .data = TestBuffer::createFromVector<_Float16>({}),
12374 .dimensions = {2, 2, 5},
12375 .isIgnored = false,
12376 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
12377 .numberOfConsumers = 1,
12378 .scale = 0.0f,
12379 .type = TestOperandType::TENSOR_FLOAT16,
12380 .zeroPoint = 0
12381 }, { // param2
12382 .channelQuant = {},
12383 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12384 .dimensions = {},
12385 .isIgnored = false,
12386 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12387 .numberOfConsumers = 1,
12388 .scale = 0.0f,
12389 .type = TestOperandType::FLOAT16,
12390 .zeroPoint = 0
12391 }, { // axis
12392 .channelQuant = {},
12393 .data = TestBuffer::createFromVector<int32_t>({2}),
12394 .dimensions = {},
12395 .isIgnored = false,
12396 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12397 .numberOfConsumers = 1,
12398 .scale = 0.0f,
12399 .type = TestOperandType::INT32,
12400 .zeroPoint = 0
12401 }, { // op2
12402 .channelQuant = {},
12403 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
12404 .dimensions = {2, 2, 5},
12405 .isIgnored = false,
12406 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12407 .numberOfConsumers = 0,
12408 .scale = 0.0f,
12409 .type = TestOperandType::TENSOR_FLOAT16,
12410 .zeroPoint = 0
12411 }, { // op1_new
12412 .channelQuant = {},
12413 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
12414 .dimensions = {2, 2, 5},
12415 .isIgnored = false,
12416 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12417 .numberOfConsumers = 1,
12418 .scale = 0.0f,
12419 .type = TestOperandType::TENSOR_FLOAT16,
12420 .zeroPoint = 0
12421 }, { // placeholder76
12422 .channelQuant = {},
12423 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
12424 .dimensions = {1},
12425 .isIgnored = false,
12426 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12427 .numberOfConsumers = 1,
12428 .scale = 0.0f,
12429 .type = TestOperandType::TENSOR_FLOAT16,
12430 .zeroPoint = 0
12431 }, { // param94
12432 .channelQuant = {},
12433 .data = TestBuffer::createFromVector<int32_t>({0}),
12434 .dimensions = {},
12435 .isIgnored = false,
12436 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12437 .numberOfConsumers = 1,
12438 .scale = 0.0f,
12439 .type = TestOperandType::INT32,
12440 .zeroPoint = 0
12441 }},
12442 .operations = {{
12443 .inputs = {4, 5, 6},
12444 .outputs = {0},
12445 .type = TestOperationType::ADD
12446 }, {
12447 .inputs = {0, 1, 2},
12448 .outputs = {3},
12449 .type = TestOperationType::SOFTMAX
12450 }},
12451 .outputIndexes = {3}
12452 },
12453 .minSupportedVersion = TestHalVersion::V1_2,
12454 .referenced = {}
12455 };
12456 return model;
12457 }
12458
12459 const auto dummy_test_model_axis_float16_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2_all_inputs_as_internal", get_test_model_axis_float16_dim3_axis2_all_inputs_as_internal());
12460
12461 } // namespace generated_tests::softmax_v1_2
12462
12463 namespace generated_tests::softmax_v1_2 {
12464
get_test_model_axis_float16_dim3_axis2_neg()12465 const TestModel& get_test_model_axis_float16_dim3_axis2_neg() {
12466 static TestModel model = {
12467 .expectFailure = false,
12468 .expectedMultinomialDistributionTolerance = 0,
12469 .isRelaxed = false,
12470 .main = { // axis
12471 .inputIndexes = {0},
12472 .operands = {{ // op1
12473 .channelQuant = {},
12474 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
12475 .dimensions = {2, 2, 5},
12476 .isIgnored = false,
12477 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12478 .numberOfConsumers = 1,
12479 .scale = 0.0f,
12480 .type = TestOperandType::TENSOR_FLOAT16,
12481 .zeroPoint = 0
12482 }, { // param2
12483 .channelQuant = {},
12484 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12485 .dimensions = {},
12486 .isIgnored = false,
12487 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12488 .numberOfConsumers = 1,
12489 .scale = 0.0f,
12490 .type = TestOperandType::FLOAT16,
12491 .zeroPoint = 0
12492 }, { // axis
12493 .channelQuant = {},
12494 .data = TestBuffer::createFromVector<int32_t>({-1}),
12495 .dimensions = {},
12496 .isIgnored = false,
12497 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12498 .numberOfConsumers = 1,
12499 .scale = 0.0f,
12500 .type = TestOperandType::INT32,
12501 .zeroPoint = 0
12502 }, { // op2
12503 .channelQuant = {},
12504 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
12505 .dimensions = {2, 2, 5},
12506 .isIgnored = false,
12507 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12508 .numberOfConsumers = 0,
12509 .scale = 0.0f,
12510 .type = TestOperandType::TENSOR_FLOAT16,
12511 .zeroPoint = 0
12512 }},
12513 .operations = {{
12514 .inputs = {0, 1, 2},
12515 .outputs = {3},
12516 .type = TestOperationType::SOFTMAX
12517 }},
12518 .outputIndexes = {3}
12519 },
12520 .minSupportedVersion = TestHalVersion::V1_2,
12521 .referenced = {}
12522 };
12523 return model;
12524 }
12525
12526 const auto dummy_test_model_axis_float16_dim3_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2_neg", get_test_model_axis_float16_dim3_axis2_neg());
12527
12528 } // namespace generated_tests::softmax_v1_2
12529
12530 namespace generated_tests::softmax_v1_2 {
12531
get_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal()12532 const TestModel& get_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal() {
12533 static TestModel model = {
12534 .expectFailure = false,
12535 .expectedMultinomialDistributionTolerance = 0,
12536 .isRelaxed = false,
12537 .main = { // axis
12538 .inputIndexes = {4},
12539 .operands = {{ // op1
12540 .channelQuant = {},
12541 .data = TestBuffer::createFromVector<_Float16>({}),
12542 .dimensions = {2, 2, 5},
12543 .isIgnored = false,
12544 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
12545 .numberOfConsumers = 1,
12546 .scale = 0.0f,
12547 .type = TestOperandType::TENSOR_FLOAT16,
12548 .zeroPoint = 0
12549 }, { // param2
12550 .channelQuant = {},
12551 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12552 .dimensions = {},
12553 .isIgnored = false,
12554 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12555 .numberOfConsumers = 1,
12556 .scale = 0.0f,
12557 .type = TestOperandType::FLOAT16,
12558 .zeroPoint = 0
12559 }, { // axis
12560 .channelQuant = {},
12561 .data = TestBuffer::createFromVector<int32_t>({-1}),
12562 .dimensions = {},
12563 .isIgnored = false,
12564 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12565 .numberOfConsumers = 1,
12566 .scale = 0.0f,
12567 .type = TestOperandType::INT32,
12568 .zeroPoint = 0
12569 }, { // op2
12570 .channelQuant = {},
12571 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
12572 .dimensions = {2, 2, 5},
12573 .isIgnored = false,
12574 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12575 .numberOfConsumers = 0,
12576 .scale = 0.0f,
12577 .type = TestOperandType::TENSOR_FLOAT16,
12578 .zeroPoint = 0
12579 }, { // op1_new
12580 .channelQuant = {},
12581 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f, 17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
12582 .dimensions = {2, 2, 5},
12583 .isIgnored = false,
12584 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12585 .numberOfConsumers = 1,
12586 .scale = 0.0f,
12587 .type = TestOperandType::TENSOR_FLOAT16,
12588 .zeroPoint = 0
12589 }, { // placeholder77
12590 .channelQuant = {},
12591 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
12592 .dimensions = {1},
12593 .isIgnored = false,
12594 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12595 .numberOfConsumers = 1,
12596 .scale = 0.0f,
12597 .type = TestOperandType::TENSOR_FLOAT16,
12598 .zeroPoint = 0
12599 }, { // param95
12600 .channelQuant = {},
12601 .data = TestBuffer::createFromVector<int32_t>({0}),
12602 .dimensions = {},
12603 .isIgnored = false,
12604 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12605 .numberOfConsumers = 1,
12606 .scale = 0.0f,
12607 .type = TestOperandType::INT32,
12608 .zeroPoint = 0
12609 }},
12610 .operations = {{
12611 .inputs = {4, 5, 6},
12612 .outputs = {0},
12613 .type = TestOperationType::ADD
12614 }, {
12615 .inputs = {0, 1, 2},
12616 .outputs = {3},
12617 .type = TestOperationType::SOFTMAX
12618 }},
12619 .outputIndexes = {3}
12620 },
12621 .minSupportedVersion = TestHalVersion::V1_2,
12622 .referenced = {}
12623 };
12624 return model;
12625 }
12626
12627 const auto dummy_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2_neg_all_inputs_as_internal", get_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal());
12628
12629 } // namespace generated_tests::softmax_v1_2
12630
12631 namespace generated_tests::softmax_v1_2 {
12632
get_test_model_axis_float16_dim2_axis0()12633 const TestModel& get_test_model_axis_float16_dim2_axis0() {
12634 static TestModel model = {
12635 .expectFailure = false,
12636 .expectedMultinomialDistributionTolerance = 0,
12637 .isRelaxed = false,
12638 .main = { // axis
12639 .inputIndexes = {0},
12640 .operands = {{ // op1
12641 .channelQuant = {},
12642 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
12643 .dimensions = {5, 2},
12644 .isIgnored = false,
12645 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12646 .numberOfConsumers = 1,
12647 .scale = 0.0f,
12648 .type = TestOperandType::TENSOR_FLOAT16,
12649 .zeroPoint = 0
12650 }, { // param2
12651 .channelQuant = {},
12652 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12653 .dimensions = {},
12654 .isIgnored = false,
12655 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12656 .numberOfConsumers = 1,
12657 .scale = 0.0f,
12658 .type = TestOperandType::FLOAT16,
12659 .zeroPoint = 0
12660 }, { // axis
12661 .channelQuant = {},
12662 .data = TestBuffer::createFromVector<int32_t>({0}),
12663 .dimensions = {},
12664 .isIgnored = false,
12665 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12666 .numberOfConsumers = 1,
12667 .scale = 0.0f,
12668 .type = TestOperandType::INT32,
12669 .zeroPoint = 0
12670 }, { // op2
12671 .channelQuant = {},
12672 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12673 .dimensions = {5, 2},
12674 .isIgnored = false,
12675 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12676 .numberOfConsumers = 0,
12677 .scale = 0.0f,
12678 .type = TestOperandType::TENSOR_FLOAT16,
12679 .zeroPoint = 0
12680 }},
12681 .operations = {{
12682 .inputs = {0, 1, 2},
12683 .outputs = {3},
12684 .type = TestOperationType::SOFTMAX
12685 }},
12686 .outputIndexes = {3}
12687 },
12688 .minSupportedVersion = TestHalVersion::V1_2,
12689 .referenced = {}
12690 };
12691 return model;
12692 }
12693
12694 const auto dummy_test_model_axis_float16_dim2_axis0 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0", get_test_model_axis_float16_dim2_axis0());
12695
12696 } // namespace generated_tests::softmax_v1_2
12697
12698 namespace generated_tests::softmax_v1_2 {
12699
get_test_model_axis_float16_dim2_axis0_all_inputs_as_internal()12700 const TestModel& get_test_model_axis_float16_dim2_axis0_all_inputs_as_internal() {
12701 static TestModel model = {
12702 .expectFailure = false,
12703 .expectedMultinomialDistributionTolerance = 0,
12704 .isRelaxed = false,
12705 .main = { // axis
12706 .inputIndexes = {4},
12707 .operands = {{ // op1
12708 .channelQuant = {},
12709 .data = TestBuffer::createFromVector<_Float16>({}),
12710 .dimensions = {5, 2},
12711 .isIgnored = false,
12712 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
12713 .numberOfConsumers = 1,
12714 .scale = 0.0f,
12715 .type = TestOperandType::TENSOR_FLOAT16,
12716 .zeroPoint = 0
12717 }, { // param2
12718 .channelQuant = {},
12719 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12720 .dimensions = {},
12721 .isIgnored = false,
12722 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12723 .numberOfConsumers = 1,
12724 .scale = 0.0f,
12725 .type = TestOperandType::FLOAT16,
12726 .zeroPoint = 0
12727 }, { // axis
12728 .channelQuant = {},
12729 .data = TestBuffer::createFromVector<int32_t>({0}),
12730 .dimensions = {},
12731 .isIgnored = false,
12732 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12733 .numberOfConsumers = 1,
12734 .scale = 0.0f,
12735 .type = TestOperandType::INT32,
12736 .zeroPoint = 0
12737 }, { // op2
12738 .channelQuant = {},
12739 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12740 .dimensions = {5, 2},
12741 .isIgnored = false,
12742 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12743 .numberOfConsumers = 0,
12744 .scale = 0.0f,
12745 .type = TestOperandType::TENSOR_FLOAT16,
12746 .zeroPoint = 0
12747 }, { // op1_new
12748 .channelQuant = {},
12749 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
12750 .dimensions = {5, 2},
12751 .isIgnored = false,
12752 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12753 .numberOfConsumers = 1,
12754 .scale = 0.0f,
12755 .type = TestOperandType::TENSOR_FLOAT16,
12756 .zeroPoint = 0
12757 }, { // placeholder78
12758 .channelQuant = {},
12759 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
12760 .dimensions = {1},
12761 .isIgnored = false,
12762 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12763 .numberOfConsumers = 1,
12764 .scale = 0.0f,
12765 .type = TestOperandType::TENSOR_FLOAT16,
12766 .zeroPoint = 0
12767 }, { // param96
12768 .channelQuant = {},
12769 .data = TestBuffer::createFromVector<int32_t>({0}),
12770 .dimensions = {},
12771 .isIgnored = false,
12772 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12773 .numberOfConsumers = 1,
12774 .scale = 0.0f,
12775 .type = TestOperandType::INT32,
12776 .zeroPoint = 0
12777 }},
12778 .operations = {{
12779 .inputs = {4, 5, 6},
12780 .outputs = {0},
12781 .type = TestOperationType::ADD
12782 }, {
12783 .inputs = {0, 1, 2},
12784 .outputs = {3},
12785 .type = TestOperationType::SOFTMAX
12786 }},
12787 .outputIndexes = {3}
12788 },
12789 .minSupportedVersion = TestHalVersion::V1_2,
12790 .referenced = {}
12791 };
12792 return model;
12793 }
12794
12795 const auto dummy_test_model_axis_float16_dim2_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0_all_inputs_as_internal", get_test_model_axis_float16_dim2_axis0_all_inputs_as_internal());
12796
12797 } // namespace generated_tests::softmax_v1_2
12798
12799 namespace generated_tests::softmax_v1_2 {
12800
get_test_model_axis_float16_dim2_axis0_neg()12801 const TestModel& get_test_model_axis_float16_dim2_axis0_neg() {
12802 static TestModel model = {
12803 .expectFailure = false,
12804 .expectedMultinomialDistributionTolerance = 0,
12805 .isRelaxed = false,
12806 .main = { // axis
12807 .inputIndexes = {0},
12808 .operands = {{ // op1
12809 .channelQuant = {},
12810 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
12811 .dimensions = {5, 2},
12812 .isIgnored = false,
12813 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12814 .numberOfConsumers = 1,
12815 .scale = 0.0f,
12816 .type = TestOperandType::TENSOR_FLOAT16,
12817 .zeroPoint = 0
12818 }, { // param2
12819 .channelQuant = {},
12820 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12821 .dimensions = {},
12822 .isIgnored = false,
12823 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12824 .numberOfConsumers = 1,
12825 .scale = 0.0f,
12826 .type = TestOperandType::FLOAT16,
12827 .zeroPoint = 0
12828 }, { // axis
12829 .channelQuant = {},
12830 .data = TestBuffer::createFromVector<int32_t>({-2}),
12831 .dimensions = {},
12832 .isIgnored = false,
12833 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12834 .numberOfConsumers = 1,
12835 .scale = 0.0f,
12836 .type = TestOperandType::INT32,
12837 .zeroPoint = 0
12838 }, { // op2
12839 .channelQuant = {},
12840 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12841 .dimensions = {5, 2},
12842 .isIgnored = false,
12843 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12844 .numberOfConsumers = 0,
12845 .scale = 0.0f,
12846 .type = TestOperandType::TENSOR_FLOAT16,
12847 .zeroPoint = 0
12848 }},
12849 .operations = {{
12850 .inputs = {0, 1, 2},
12851 .outputs = {3},
12852 .type = TestOperationType::SOFTMAX
12853 }},
12854 .outputIndexes = {3}
12855 },
12856 .minSupportedVersion = TestHalVersion::V1_2,
12857 .referenced = {}
12858 };
12859 return model;
12860 }
12861
12862 const auto dummy_test_model_axis_float16_dim2_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0_neg", get_test_model_axis_float16_dim2_axis0_neg());
12863
12864 } // namespace generated_tests::softmax_v1_2
12865
12866 namespace generated_tests::softmax_v1_2 {
12867
get_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal()12868 const TestModel& get_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal() {
12869 static TestModel model = {
12870 .expectFailure = false,
12871 .expectedMultinomialDistributionTolerance = 0,
12872 .isRelaxed = false,
12873 .main = { // axis
12874 .inputIndexes = {4},
12875 .operands = {{ // op1
12876 .channelQuant = {},
12877 .data = TestBuffer::createFromVector<_Float16>({}),
12878 .dimensions = {5, 2},
12879 .isIgnored = false,
12880 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
12881 .numberOfConsumers = 1,
12882 .scale = 0.0f,
12883 .type = TestOperandType::TENSOR_FLOAT16,
12884 .zeroPoint = 0
12885 }, { // param2
12886 .channelQuant = {},
12887 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12888 .dimensions = {},
12889 .isIgnored = false,
12890 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12891 .numberOfConsumers = 1,
12892 .scale = 0.0f,
12893 .type = TestOperandType::FLOAT16,
12894 .zeroPoint = 0
12895 }, { // axis
12896 .channelQuant = {},
12897 .data = TestBuffer::createFromVector<int32_t>({-2}),
12898 .dimensions = {},
12899 .isIgnored = false,
12900 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12901 .numberOfConsumers = 1,
12902 .scale = 0.0f,
12903 .type = TestOperandType::INT32,
12904 .zeroPoint = 0
12905 }, { // op2
12906 .channelQuant = {},
12907 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.6439142227172852f, 0.23688280582427979f, 0.23688280582427979f, 0.08714431524276733f, 0.08714431524276733f, 0.03205860033631325f, 0.03205860033631325f, 7.246299560392799e-08f, 7.246299560392799e-08f}),
12908 .dimensions = {5, 2},
12909 .isIgnored = false,
12910 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
12911 .numberOfConsumers = 0,
12912 .scale = 0.0f,
12913 .type = TestOperandType::TENSOR_FLOAT16,
12914 .zeroPoint = 0
12915 }, { // op1_new
12916 .channelQuant = {},
12917 .data = TestBuffer::createFromVector<_Float16>({17.0f, -1.0f, 16.0f, -2.0f, 15.0f, -3.0f, 14.0f, -4.0f, 1.0f, -17.0f}),
12918 .dimensions = {5, 2},
12919 .isIgnored = false,
12920 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12921 .numberOfConsumers = 1,
12922 .scale = 0.0f,
12923 .type = TestOperandType::TENSOR_FLOAT16,
12924 .zeroPoint = 0
12925 }, { // placeholder79
12926 .channelQuant = {},
12927 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
12928 .dimensions = {1},
12929 .isIgnored = false,
12930 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12931 .numberOfConsumers = 1,
12932 .scale = 0.0f,
12933 .type = TestOperandType::TENSOR_FLOAT16,
12934 .zeroPoint = 0
12935 }, { // param97
12936 .channelQuant = {},
12937 .data = TestBuffer::createFromVector<int32_t>({0}),
12938 .dimensions = {},
12939 .isIgnored = false,
12940 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12941 .numberOfConsumers = 1,
12942 .scale = 0.0f,
12943 .type = TestOperandType::INT32,
12944 .zeroPoint = 0
12945 }},
12946 .operations = {{
12947 .inputs = {4, 5, 6},
12948 .outputs = {0},
12949 .type = TestOperationType::ADD
12950 }, {
12951 .inputs = {0, 1, 2},
12952 .outputs = {3},
12953 .type = TestOperationType::SOFTMAX
12954 }},
12955 .outputIndexes = {3}
12956 },
12957 .minSupportedVersion = TestHalVersion::V1_2,
12958 .referenced = {}
12959 };
12960 return model;
12961 }
12962
12963 const auto dummy_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0_neg_all_inputs_as_internal", get_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal());
12964
12965 } // namespace generated_tests::softmax_v1_2
12966
12967 namespace generated_tests::softmax_v1_2 {
12968
get_test_model_axis_float16_dim2_axis1()12969 const TestModel& get_test_model_axis_float16_dim2_axis1() {
12970 static TestModel model = {
12971 .expectFailure = false,
12972 .expectedMultinomialDistributionTolerance = 0,
12973 .isRelaxed = false,
12974 .main = { // axis
12975 .inputIndexes = {0},
12976 .operands = {{ // op1
12977 .channelQuant = {},
12978 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
12979 .dimensions = {2, 5},
12980 .isIgnored = false,
12981 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
12982 .numberOfConsumers = 1,
12983 .scale = 0.0f,
12984 .type = TestOperandType::TENSOR_FLOAT16,
12985 .zeroPoint = 0
12986 }, { // param2
12987 .channelQuant = {},
12988 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
12989 .dimensions = {},
12990 .isIgnored = false,
12991 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
12992 .numberOfConsumers = 1,
12993 .scale = 0.0f,
12994 .type = TestOperandType::FLOAT16,
12995 .zeroPoint = 0
12996 }, { // axis
12997 .channelQuant = {},
12998 .data = TestBuffer::createFromVector<int32_t>({1}),
12999 .dimensions = {},
13000 .isIgnored = false,
13001 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13002 .numberOfConsumers = 1,
13003 .scale = 0.0f,
13004 .type = TestOperandType::INT32,
13005 .zeroPoint = 0
13006 }, { // op2
13007 .channelQuant = {},
13008 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13009 .dimensions = {2, 5},
13010 .isIgnored = false,
13011 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13012 .numberOfConsumers = 0,
13013 .scale = 0.0f,
13014 .type = TestOperandType::TENSOR_FLOAT16,
13015 .zeroPoint = 0
13016 }},
13017 .operations = {{
13018 .inputs = {0, 1, 2},
13019 .outputs = {3},
13020 .type = TestOperationType::SOFTMAX
13021 }},
13022 .outputIndexes = {3}
13023 },
13024 .minSupportedVersion = TestHalVersion::V1_2,
13025 .referenced = {}
13026 };
13027 return model;
13028 }
13029
13030 const auto dummy_test_model_axis_float16_dim2_axis1 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1", get_test_model_axis_float16_dim2_axis1());
13031
13032 } // namespace generated_tests::softmax_v1_2
13033
13034 namespace generated_tests::softmax_v1_2 {
13035
get_test_model_axis_float16_dim2_axis1_all_inputs_as_internal()13036 const TestModel& get_test_model_axis_float16_dim2_axis1_all_inputs_as_internal() {
13037 static TestModel model = {
13038 .expectFailure = false,
13039 .expectedMultinomialDistributionTolerance = 0,
13040 .isRelaxed = false,
13041 .main = { // axis
13042 .inputIndexes = {4},
13043 .operands = {{ // op1
13044 .channelQuant = {},
13045 .data = TestBuffer::createFromVector<_Float16>({}),
13046 .dimensions = {2, 5},
13047 .isIgnored = false,
13048 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
13049 .numberOfConsumers = 1,
13050 .scale = 0.0f,
13051 .type = TestOperandType::TENSOR_FLOAT16,
13052 .zeroPoint = 0
13053 }, { // param2
13054 .channelQuant = {},
13055 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
13056 .dimensions = {},
13057 .isIgnored = false,
13058 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13059 .numberOfConsumers = 1,
13060 .scale = 0.0f,
13061 .type = TestOperandType::FLOAT16,
13062 .zeroPoint = 0
13063 }, { // axis
13064 .channelQuant = {},
13065 .data = TestBuffer::createFromVector<int32_t>({1}),
13066 .dimensions = {},
13067 .isIgnored = false,
13068 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13069 .numberOfConsumers = 1,
13070 .scale = 0.0f,
13071 .type = TestOperandType::INT32,
13072 .zeroPoint = 0
13073 }, { // op2
13074 .channelQuant = {},
13075 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13076 .dimensions = {2, 5},
13077 .isIgnored = false,
13078 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13079 .numberOfConsumers = 0,
13080 .scale = 0.0f,
13081 .type = TestOperandType::TENSOR_FLOAT16,
13082 .zeroPoint = 0
13083 }, { // op1_new
13084 .channelQuant = {},
13085 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
13086 .dimensions = {2, 5},
13087 .isIgnored = false,
13088 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13089 .numberOfConsumers = 1,
13090 .scale = 0.0f,
13091 .type = TestOperandType::TENSOR_FLOAT16,
13092 .zeroPoint = 0
13093 }, { // placeholder80
13094 .channelQuant = {},
13095 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
13096 .dimensions = {1},
13097 .isIgnored = false,
13098 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13099 .numberOfConsumers = 1,
13100 .scale = 0.0f,
13101 .type = TestOperandType::TENSOR_FLOAT16,
13102 .zeroPoint = 0
13103 }, { // param98
13104 .channelQuant = {},
13105 .data = TestBuffer::createFromVector<int32_t>({0}),
13106 .dimensions = {},
13107 .isIgnored = false,
13108 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13109 .numberOfConsumers = 1,
13110 .scale = 0.0f,
13111 .type = TestOperandType::INT32,
13112 .zeroPoint = 0
13113 }},
13114 .operations = {{
13115 .inputs = {4, 5, 6},
13116 .outputs = {0},
13117 .type = TestOperationType::ADD
13118 }, {
13119 .inputs = {0, 1, 2},
13120 .outputs = {3},
13121 .type = TestOperationType::SOFTMAX
13122 }},
13123 .outputIndexes = {3}
13124 },
13125 .minSupportedVersion = TestHalVersion::V1_2,
13126 .referenced = {}
13127 };
13128 return model;
13129 }
13130
13131 const auto dummy_test_model_axis_float16_dim2_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1_all_inputs_as_internal", get_test_model_axis_float16_dim2_axis1_all_inputs_as_internal());
13132
13133 } // namespace generated_tests::softmax_v1_2
13134
13135 namespace generated_tests::softmax_v1_2 {
13136
get_test_model_axis_float16_dim2_axis1_neg()13137 const TestModel& get_test_model_axis_float16_dim2_axis1_neg() {
13138 static TestModel model = {
13139 .expectFailure = false,
13140 .expectedMultinomialDistributionTolerance = 0,
13141 .isRelaxed = false,
13142 .main = { // axis
13143 .inputIndexes = {0},
13144 .operands = {{ // op1
13145 .channelQuant = {},
13146 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
13147 .dimensions = {2, 5},
13148 .isIgnored = false,
13149 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13150 .numberOfConsumers = 1,
13151 .scale = 0.0f,
13152 .type = TestOperandType::TENSOR_FLOAT16,
13153 .zeroPoint = 0
13154 }, { // param2
13155 .channelQuant = {},
13156 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
13157 .dimensions = {},
13158 .isIgnored = false,
13159 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13160 .numberOfConsumers = 1,
13161 .scale = 0.0f,
13162 .type = TestOperandType::FLOAT16,
13163 .zeroPoint = 0
13164 }, { // axis
13165 .channelQuant = {},
13166 .data = TestBuffer::createFromVector<int32_t>({-1}),
13167 .dimensions = {},
13168 .isIgnored = false,
13169 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13170 .numberOfConsumers = 1,
13171 .scale = 0.0f,
13172 .type = TestOperandType::INT32,
13173 .zeroPoint = 0
13174 }, { // op2
13175 .channelQuant = {},
13176 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13177 .dimensions = {2, 5},
13178 .isIgnored = false,
13179 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13180 .numberOfConsumers = 0,
13181 .scale = 0.0f,
13182 .type = TestOperandType::TENSOR_FLOAT16,
13183 .zeroPoint = 0
13184 }},
13185 .operations = {{
13186 .inputs = {0, 1, 2},
13187 .outputs = {3},
13188 .type = TestOperationType::SOFTMAX
13189 }},
13190 .outputIndexes = {3}
13191 },
13192 .minSupportedVersion = TestHalVersion::V1_2,
13193 .referenced = {}
13194 };
13195 return model;
13196 }
13197
13198 const auto dummy_test_model_axis_float16_dim2_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1_neg", get_test_model_axis_float16_dim2_axis1_neg());
13199
13200 } // namespace generated_tests::softmax_v1_2
13201
13202 namespace generated_tests::softmax_v1_2 {
13203
get_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal()13204 const TestModel& get_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal() {
13205 static TestModel model = {
13206 .expectFailure = false,
13207 .expectedMultinomialDistributionTolerance = 0,
13208 .isRelaxed = false,
13209 .main = { // axis
13210 .inputIndexes = {4},
13211 .operands = {{ // op1
13212 .channelQuant = {},
13213 .data = TestBuffer::createFromVector<_Float16>({}),
13214 .dimensions = {2, 5},
13215 .isIgnored = false,
13216 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
13217 .numberOfConsumers = 1,
13218 .scale = 0.0f,
13219 .type = TestOperandType::TENSOR_FLOAT16,
13220 .zeroPoint = 0
13221 }, { // param2
13222 .channelQuant = {},
13223 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
13224 .dimensions = {},
13225 .isIgnored = false,
13226 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13227 .numberOfConsumers = 1,
13228 .scale = 0.0f,
13229 .type = TestOperandType::FLOAT16,
13230 .zeroPoint = 0
13231 }, { // axis
13232 .channelQuant = {},
13233 .data = TestBuffer::createFromVector<int32_t>({-1}),
13234 .dimensions = {},
13235 .isIgnored = false,
13236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13237 .numberOfConsumers = 1,
13238 .scale = 0.0f,
13239 .type = TestOperandType::INT32,
13240 .zeroPoint = 0
13241 }, { // op2
13242 .channelQuant = {},
13243 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f, 0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13244 .dimensions = {2, 5},
13245 .isIgnored = false,
13246 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13247 .numberOfConsumers = 0,
13248 .scale = 0.0f,
13249 .type = TestOperandType::TENSOR_FLOAT16,
13250 .zeroPoint = 0
13251 }, { // op1_new
13252 .channelQuant = {},
13253 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f, -1.0f, -2.0f, -3.0f, -4.0f, -17.0f}),
13254 .dimensions = {2, 5},
13255 .isIgnored = false,
13256 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13257 .numberOfConsumers = 1,
13258 .scale = 0.0f,
13259 .type = TestOperandType::TENSOR_FLOAT16,
13260 .zeroPoint = 0
13261 }, { // placeholder81
13262 .channelQuant = {},
13263 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
13264 .dimensions = {1},
13265 .isIgnored = false,
13266 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13267 .numberOfConsumers = 1,
13268 .scale = 0.0f,
13269 .type = TestOperandType::TENSOR_FLOAT16,
13270 .zeroPoint = 0
13271 }, { // param99
13272 .channelQuant = {},
13273 .data = TestBuffer::createFromVector<int32_t>({0}),
13274 .dimensions = {},
13275 .isIgnored = false,
13276 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13277 .numberOfConsumers = 1,
13278 .scale = 0.0f,
13279 .type = TestOperandType::INT32,
13280 .zeroPoint = 0
13281 }},
13282 .operations = {{
13283 .inputs = {4, 5, 6},
13284 .outputs = {0},
13285 .type = TestOperationType::ADD
13286 }, {
13287 .inputs = {0, 1, 2},
13288 .outputs = {3},
13289 .type = TestOperationType::SOFTMAX
13290 }},
13291 .outputIndexes = {3}
13292 },
13293 .minSupportedVersion = TestHalVersion::V1_2,
13294 .referenced = {}
13295 };
13296 return model;
13297 }
13298
13299 const auto dummy_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1_neg_all_inputs_as_internal", get_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal());
13300
13301 } // namespace generated_tests::softmax_v1_2
13302
13303 namespace generated_tests::softmax_v1_2 {
13304
get_test_model_axis_float16_dim1_axis0()13305 const TestModel& get_test_model_axis_float16_dim1_axis0() {
13306 static TestModel model = {
13307 .expectFailure = false,
13308 .expectedMultinomialDistributionTolerance = 0,
13309 .isRelaxed = false,
13310 .main = { // axis
13311 .inputIndexes = {0},
13312 .operands = {{ // op1
13313 .channelQuant = {},
13314 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
13315 .dimensions = {5},
13316 .isIgnored = false,
13317 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13318 .numberOfConsumers = 1,
13319 .scale = 0.0f,
13320 .type = TestOperandType::TENSOR_FLOAT16,
13321 .zeroPoint = 0
13322 }, { // param2
13323 .channelQuant = {},
13324 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
13325 .dimensions = {},
13326 .isIgnored = false,
13327 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13328 .numberOfConsumers = 1,
13329 .scale = 0.0f,
13330 .type = TestOperandType::FLOAT16,
13331 .zeroPoint = 0
13332 }, { // axis
13333 .channelQuant = {},
13334 .data = TestBuffer::createFromVector<int32_t>({0}),
13335 .dimensions = {},
13336 .isIgnored = false,
13337 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13338 .numberOfConsumers = 1,
13339 .scale = 0.0f,
13340 .type = TestOperandType::INT32,
13341 .zeroPoint = 0
13342 }, { // op2
13343 .channelQuant = {},
13344 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13345 .dimensions = {5},
13346 .isIgnored = false,
13347 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13348 .numberOfConsumers = 0,
13349 .scale = 0.0f,
13350 .type = TestOperandType::TENSOR_FLOAT16,
13351 .zeroPoint = 0
13352 }},
13353 .operations = {{
13354 .inputs = {0, 1, 2},
13355 .outputs = {3},
13356 .type = TestOperationType::SOFTMAX
13357 }},
13358 .outputIndexes = {3}
13359 },
13360 .minSupportedVersion = TestHalVersion::V1_2,
13361 .referenced = {}
13362 };
13363 return model;
13364 }
13365
13366 const auto dummy_test_model_axis_float16_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0", get_test_model_axis_float16_dim1_axis0());
13367
13368 } // namespace generated_tests::softmax_v1_2
13369
13370 namespace generated_tests::softmax_v1_2 {
13371
get_test_model_axis_float16_dim1_axis0_all_inputs_as_internal()13372 const TestModel& get_test_model_axis_float16_dim1_axis0_all_inputs_as_internal() {
13373 static TestModel model = {
13374 .expectFailure = false,
13375 .expectedMultinomialDistributionTolerance = 0,
13376 .isRelaxed = false,
13377 .main = { // axis
13378 .inputIndexes = {4},
13379 .operands = {{ // op1
13380 .channelQuant = {},
13381 .data = TestBuffer::createFromVector<_Float16>({}),
13382 .dimensions = {5},
13383 .isIgnored = false,
13384 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
13385 .numberOfConsumers = 1,
13386 .scale = 0.0f,
13387 .type = TestOperandType::TENSOR_FLOAT16,
13388 .zeroPoint = 0
13389 }, { // param2
13390 .channelQuant = {},
13391 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
13392 .dimensions = {},
13393 .isIgnored = false,
13394 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13395 .numberOfConsumers = 1,
13396 .scale = 0.0f,
13397 .type = TestOperandType::FLOAT16,
13398 .zeroPoint = 0
13399 }, { // axis
13400 .channelQuant = {},
13401 .data = TestBuffer::createFromVector<int32_t>({0}),
13402 .dimensions = {},
13403 .isIgnored = false,
13404 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13405 .numberOfConsumers = 1,
13406 .scale = 0.0f,
13407 .type = TestOperandType::INT32,
13408 .zeroPoint = 0
13409 }, { // op2
13410 .channelQuant = {},
13411 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13412 .dimensions = {5},
13413 .isIgnored = false,
13414 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13415 .numberOfConsumers = 0,
13416 .scale = 0.0f,
13417 .type = TestOperandType::TENSOR_FLOAT16,
13418 .zeroPoint = 0
13419 }, { // op1_new
13420 .channelQuant = {},
13421 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
13422 .dimensions = {5},
13423 .isIgnored = false,
13424 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13425 .numberOfConsumers = 1,
13426 .scale = 0.0f,
13427 .type = TestOperandType::TENSOR_FLOAT16,
13428 .zeroPoint = 0
13429 }, { // placeholder82
13430 .channelQuant = {},
13431 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
13432 .dimensions = {1},
13433 .isIgnored = false,
13434 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13435 .numberOfConsumers = 1,
13436 .scale = 0.0f,
13437 .type = TestOperandType::TENSOR_FLOAT16,
13438 .zeroPoint = 0
13439 }, { // param100
13440 .channelQuant = {},
13441 .data = TestBuffer::createFromVector<int32_t>({0}),
13442 .dimensions = {},
13443 .isIgnored = false,
13444 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13445 .numberOfConsumers = 1,
13446 .scale = 0.0f,
13447 .type = TestOperandType::INT32,
13448 .zeroPoint = 0
13449 }},
13450 .operations = {{
13451 .inputs = {4, 5, 6},
13452 .outputs = {0},
13453 .type = TestOperationType::ADD
13454 }, {
13455 .inputs = {0, 1, 2},
13456 .outputs = {3},
13457 .type = TestOperationType::SOFTMAX
13458 }},
13459 .outputIndexes = {3}
13460 },
13461 .minSupportedVersion = TestHalVersion::V1_2,
13462 .referenced = {}
13463 };
13464 return model;
13465 }
13466
13467 const auto dummy_test_model_axis_float16_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0_all_inputs_as_internal", get_test_model_axis_float16_dim1_axis0_all_inputs_as_internal());
13468
13469 } // namespace generated_tests::softmax_v1_2
13470
13471 namespace generated_tests::softmax_v1_2 {
13472
get_test_model_axis_float16_dim1_axis0_neg()13473 const TestModel& get_test_model_axis_float16_dim1_axis0_neg() {
13474 static TestModel model = {
13475 .expectFailure = false,
13476 .expectedMultinomialDistributionTolerance = 0,
13477 .isRelaxed = false,
13478 .main = { // axis
13479 .inputIndexes = {0},
13480 .operands = {{ // op1
13481 .channelQuant = {},
13482 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
13483 .dimensions = {5},
13484 .isIgnored = false,
13485 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13486 .numberOfConsumers = 1,
13487 .scale = 0.0f,
13488 .type = TestOperandType::TENSOR_FLOAT16,
13489 .zeroPoint = 0
13490 }, { // param2
13491 .channelQuant = {},
13492 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
13493 .dimensions = {},
13494 .isIgnored = false,
13495 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13496 .numberOfConsumers = 1,
13497 .scale = 0.0f,
13498 .type = TestOperandType::FLOAT16,
13499 .zeroPoint = 0
13500 }, { // axis
13501 .channelQuant = {},
13502 .data = TestBuffer::createFromVector<int32_t>({-1}),
13503 .dimensions = {},
13504 .isIgnored = false,
13505 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13506 .numberOfConsumers = 1,
13507 .scale = 0.0f,
13508 .type = TestOperandType::INT32,
13509 .zeroPoint = 0
13510 }, { // op2
13511 .channelQuant = {},
13512 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13513 .dimensions = {5},
13514 .isIgnored = false,
13515 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13516 .numberOfConsumers = 0,
13517 .scale = 0.0f,
13518 .type = TestOperandType::TENSOR_FLOAT16,
13519 .zeroPoint = 0
13520 }},
13521 .operations = {{
13522 .inputs = {0, 1, 2},
13523 .outputs = {3},
13524 .type = TestOperationType::SOFTMAX
13525 }},
13526 .outputIndexes = {3}
13527 },
13528 .minSupportedVersion = TestHalVersion::V1_2,
13529 .referenced = {}
13530 };
13531 return model;
13532 }
13533
13534 const auto dummy_test_model_axis_float16_dim1_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0_neg", get_test_model_axis_float16_dim1_axis0_neg());
13535
13536 } // namespace generated_tests::softmax_v1_2
13537
13538 namespace generated_tests::softmax_v1_2 {
13539
get_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal()13540 const TestModel& get_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal() {
13541 static TestModel model = {
13542 .expectFailure = false,
13543 .expectedMultinomialDistributionTolerance = 0,
13544 .isRelaxed = false,
13545 .main = { // axis
13546 .inputIndexes = {4},
13547 .operands = {{ // op1
13548 .channelQuant = {},
13549 .data = TestBuffer::createFromVector<_Float16>({}),
13550 .dimensions = {5},
13551 .isIgnored = false,
13552 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
13553 .numberOfConsumers = 1,
13554 .scale = 0.0f,
13555 .type = TestOperandType::TENSOR_FLOAT16,
13556 .zeroPoint = 0
13557 }, { // param2
13558 .channelQuant = {},
13559 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
13560 .dimensions = {},
13561 .isIgnored = false,
13562 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13563 .numberOfConsumers = 1,
13564 .scale = 0.0f,
13565 .type = TestOperandType::FLOAT16,
13566 .zeroPoint = 0
13567 }, { // axis
13568 .channelQuant = {},
13569 .data = TestBuffer::createFromVector<int32_t>({-1}),
13570 .dimensions = {},
13571 .isIgnored = false,
13572 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13573 .numberOfConsumers = 1,
13574 .scale = 0.0f,
13575 .type = TestOperandType::INT32,
13576 .zeroPoint = 0
13577 }, { // op2
13578 .channelQuant = {},
13579 .data = TestBuffer::createFromVector<_Float16>({0.6439142227172852f, 0.23688280582427979f, 0.08714431524276733f, 0.03205860033631325f, 7.246299560392799e-08f}),
13580 .dimensions = {5},
13581 .isIgnored = false,
13582 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13583 .numberOfConsumers = 0,
13584 .scale = 0.0f,
13585 .type = TestOperandType::TENSOR_FLOAT16,
13586 .zeroPoint = 0
13587 }, { // op1_new
13588 .channelQuant = {},
13589 .data = TestBuffer::createFromVector<_Float16>({17.0f, 16.0f, 15.0f, 14.0f, 1.0f}),
13590 .dimensions = {5},
13591 .isIgnored = false,
13592 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13593 .numberOfConsumers = 1,
13594 .scale = 0.0f,
13595 .type = TestOperandType::TENSOR_FLOAT16,
13596 .zeroPoint = 0
13597 }, { // placeholder83
13598 .channelQuant = {},
13599 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
13600 .dimensions = {1},
13601 .isIgnored = false,
13602 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13603 .numberOfConsumers = 1,
13604 .scale = 0.0f,
13605 .type = TestOperandType::TENSOR_FLOAT16,
13606 .zeroPoint = 0
13607 }, { // param101
13608 .channelQuant = {},
13609 .data = TestBuffer::createFromVector<int32_t>({0}),
13610 .dimensions = {},
13611 .isIgnored = false,
13612 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13613 .numberOfConsumers = 1,
13614 .scale = 0.0f,
13615 .type = TestOperandType::INT32,
13616 .zeroPoint = 0
13617 }},
13618 .operations = {{
13619 .inputs = {4, 5, 6},
13620 .outputs = {0},
13621 .type = TestOperationType::ADD
13622 }, {
13623 .inputs = {0, 1, 2},
13624 .outputs = {3},
13625 .type = TestOperationType::SOFTMAX
13626 }},
13627 .outputIndexes = {3}
13628 },
13629 .minSupportedVersion = TestHalVersion::V1_2,
13630 .referenced = {}
13631 };
13632 return model;
13633 }
13634
13635 const auto dummy_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0_neg_all_inputs_as_internal", get_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal());
13636
13637 } // namespace generated_tests::softmax_v1_2
13638
13639 namespace generated_tests::softmax_v1_2 {
13640
get_test_model_axis_quant8_dim4_axis0()13641 const TestModel& get_test_model_axis_quant8_dim4_axis0() {
13642 static TestModel model = {
13643 .expectFailure = false,
13644 .expectedMultinomialDistributionTolerance = 0,
13645 .isRelaxed = false,
13646 .main = { // axis
13647 .inputIndexes = {0},
13648 .operands = {{ // op1
13649 .channelQuant = {},
13650 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 196, 124, 196, 124, 192, 120, 192, 120, 192, 120, 192, 120, 188, 116, 188, 116, 188, 116, 188, 116, 184, 112, 184, 112, 184, 112, 184, 112, 132, 60, 132, 60, 132, 60, 132, 60}),
13651 .dimensions = {5, 2, 2, 2},
13652 .isIgnored = false,
13653 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13654 .numberOfConsumers = 1,
13655 .scale = 0.25f,
13656 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13657 .zeroPoint = 128
13658 }, { // param2
13659 .channelQuant = {},
13660 .data = TestBuffer::createFromVector<float>({1.0f}),
13661 .dimensions = {},
13662 .isIgnored = false,
13663 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13664 .numberOfConsumers = 1,
13665 .scale = 0.0f,
13666 .type = TestOperandType::FLOAT32,
13667 .zeroPoint = 0
13668 }, { // axis
13669 .channelQuant = {},
13670 .data = TestBuffer::createFromVector<int32_t>({0}),
13671 .dimensions = {},
13672 .isIgnored = false,
13673 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13674 .numberOfConsumers = 1,
13675 .scale = 0.0f,
13676 .type = TestOperandType::INT32,
13677 .zeroPoint = 0
13678 }, { // op2
13679 .channelQuant = {},
13680 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 165, 165, 165, 165, 61, 61, 61, 61, 61, 61, 61, 61, 22, 22, 22, 22, 22, 22, 22, 22, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0}),
13681 .dimensions = {5, 2, 2, 2},
13682 .isIgnored = false,
13683 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13684 .numberOfConsumers = 0,
13685 .scale = 0.00390625f,
13686 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13687 .zeroPoint = 0
13688 }},
13689 .operations = {{
13690 .inputs = {0, 1, 2},
13691 .outputs = {3},
13692 .type = TestOperationType::SOFTMAX
13693 }},
13694 .outputIndexes = {3}
13695 },
13696 .minSupportedVersion = TestHalVersion::V1_2,
13697 .referenced = {}
13698 };
13699 return model;
13700 }
13701
13702 const auto dummy_test_model_axis_quant8_dim4_axis0 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0", get_test_model_axis_quant8_dim4_axis0());
13703
13704 } // namespace generated_tests::softmax_v1_2
13705
13706 namespace generated_tests::softmax_v1_2 {
13707
get_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal()13708 const TestModel& get_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal() {
13709 static TestModel model = {
13710 .expectFailure = false,
13711 .expectedMultinomialDistributionTolerance = 0,
13712 .isRelaxed = false,
13713 .main = { // axis
13714 .inputIndexes = {4},
13715 .operands = {{ // op1
13716 .channelQuant = {},
13717 .data = TestBuffer::createFromVector<uint8_t>({}),
13718 .dimensions = {5, 2, 2, 2},
13719 .isIgnored = false,
13720 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
13721 .numberOfConsumers = 1,
13722 .scale = 0.25f,
13723 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13724 .zeroPoint = 128
13725 }, { // param2
13726 .channelQuant = {},
13727 .data = TestBuffer::createFromVector<float>({1.0f}),
13728 .dimensions = {},
13729 .isIgnored = false,
13730 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13731 .numberOfConsumers = 1,
13732 .scale = 0.0f,
13733 .type = TestOperandType::FLOAT32,
13734 .zeroPoint = 0
13735 }, { // axis
13736 .channelQuant = {},
13737 .data = TestBuffer::createFromVector<int32_t>({0}),
13738 .dimensions = {},
13739 .isIgnored = false,
13740 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13741 .numberOfConsumers = 1,
13742 .scale = 0.0f,
13743 .type = TestOperandType::INT32,
13744 .zeroPoint = 0
13745 }, { // op2
13746 .channelQuant = {},
13747 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 165, 165, 165, 165, 61, 61, 61, 61, 61, 61, 61, 61, 22, 22, 22, 22, 22, 22, 22, 22, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0}),
13748 .dimensions = {5, 2, 2, 2},
13749 .isIgnored = false,
13750 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13751 .numberOfConsumers = 0,
13752 .scale = 0.00390625f,
13753 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13754 .zeroPoint = 0
13755 }, { // op1_new
13756 .channelQuant = {},
13757 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 196, 124, 196, 124, 192, 120, 192, 120, 192, 120, 192, 120, 188, 116, 188, 116, 188, 116, 188, 116, 184, 112, 184, 112, 184, 112, 184, 112, 132, 60, 132, 60, 132, 60, 132, 60}),
13758 .dimensions = {5, 2, 2, 2},
13759 .isIgnored = false,
13760 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13761 .numberOfConsumers = 1,
13762 .scale = 0.25f,
13763 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13764 .zeroPoint = 128
13765 }, { // placeholder84
13766 .channelQuant = {},
13767 .data = TestBuffer::createFromVector<uint8_t>({128}),
13768 .dimensions = {1},
13769 .isIgnored = false,
13770 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13771 .numberOfConsumers = 1,
13772 .scale = 0.25f,
13773 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13774 .zeroPoint = 128
13775 }, { // param102
13776 .channelQuant = {},
13777 .data = TestBuffer::createFromVector<int32_t>({0}),
13778 .dimensions = {},
13779 .isIgnored = false,
13780 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13781 .numberOfConsumers = 1,
13782 .scale = 0.0f,
13783 .type = TestOperandType::INT32,
13784 .zeroPoint = 0
13785 }},
13786 .operations = {{
13787 .inputs = {4, 5, 6},
13788 .outputs = {0},
13789 .type = TestOperationType::ADD
13790 }, {
13791 .inputs = {0, 1, 2},
13792 .outputs = {3},
13793 .type = TestOperationType::SOFTMAX
13794 }},
13795 .outputIndexes = {3}
13796 },
13797 .minSupportedVersion = TestHalVersion::V1_2,
13798 .referenced = {}
13799 };
13800 return model;
13801 }
13802
13803 const auto dummy_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal());
13804
13805 } // namespace generated_tests::softmax_v1_2
13806
13807 namespace generated_tests::softmax_v1_2 {
13808
get_test_model_axis_quant8_dim4_axis0_neg()13809 const TestModel& get_test_model_axis_quant8_dim4_axis0_neg() {
13810 static TestModel model = {
13811 .expectFailure = false,
13812 .expectedMultinomialDistributionTolerance = 0,
13813 .isRelaxed = false,
13814 .main = { // axis
13815 .inputIndexes = {0},
13816 .operands = {{ // op1
13817 .channelQuant = {},
13818 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 196, 124, 196, 124, 192, 120, 192, 120, 192, 120, 192, 120, 188, 116, 188, 116, 188, 116, 188, 116, 184, 112, 184, 112, 184, 112, 184, 112, 132, 60, 132, 60, 132, 60, 132, 60}),
13819 .dimensions = {5, 2, 2, 2},
13820 .isIgnored = false,
13821 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13822 .numberOfConsumers = 1,
13823 .scale = 0.25f,
13824 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13825 .zeroPoint = 128
13826 }, { // param2
13827 .channelQuant = {},
13828 .data = TestBuffer::createFromVector<float>({1.0f}),
13829 .dimensions = {},
13830 .isIgnored = false,
13831 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13832 .numberOfConsumers = 1,
13833 .scale = 0.0f,
13834 .type = TestOperandType::FLOAT32,
13835 .zeroPoint = 0
13836 }, { // axis
13837 .channelQuant = {},
13838 .data = TestBuffer::createFromVector<int32_t>({-4}),
13839 .dimensions = {},
13840 .isIgnored = false,
13841 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13842 .numberOfConsumers = 1,
13843 .scale = 0.0f,
13844 .type = TestOperandType::INT32,
13845 .zeroPoint = 0
13846 }, { // op2
13847 .channelQuant = {},
13848 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 165, 165, 165, 165, 61, 61, 61, 61, 61, 61, 61, 61, 22, 22, 22, 22, 22, 22, 22, 22, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0}),
13849 .dimensions = {5, 2, 2, 2},
13850 .isIgnored = false,
13851 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13852 .numberOfConsumers = 0,
13853 .scale = 0.00390625f,
13854 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13855 .zeroPoint = 0
13856 }},
13857 .operations = {{
13858 .inputs = {0, 1, 2},
13859 .outputs = {3},
13860 .type = TestOperationType::SOFTMAX
13861 }},
13862 .outputIndexes = {3}
13863 },
13864 .minSupportedVersion = TestHalVersion::V1_2,
13865 .referenced = {}
13866 };
13867 return model;
13868 }
13869
13870 const auto dummy_test_model_axis_quant8_dim4_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0_neg", get_test_model_axis_quant8_dim4_axis0_neg());
13871
13872 } // namespace generated_tests::softmax_v1_2
13873
13874 namespace generated_tests::softmax_v1_2 {
13875
get_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal()13876 const TestModel& get_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal() {
13877 static TestModel model = {
13878 .expectFailure = false,
13879 .expectedMultinomialDistributionTolerance = 0,
13880 .isRelaxed = false,
13881 .main = { // axis
13882 .inputIndexes = {4},
13883 .operands = {{ // op1
13884 .channelQuant = {},
13885 .data = TestBuffer::createFromVector<uint8_t>({}),
13886 .dimensions = {5, 2, 2, 2},
13887 .isIgnored = false,
13888 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
13889 .numberOfConsumers = 1,
13890 .scale = 0.25f,
13891 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13892 .zeroPoint = 128
13893 }, { // param2
13894 .channelQuant = {},
13895 .data = TestBuffer::createFromVector<float>({1.0f}),
13896 .dimensions = {},
13897 .isIgnored = false,
13898 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13899 .numberOfConsumers = 1,
13900 .scale = 0.0f,
13901 .type = TestOperandType::FLOAT32,
13902 .zeroPoint = 0
13903 }, { // axis
13904 .channelQuant = {},
13905 .data = TestBuffer::createFromVector<int32_t>({-4}),
13906 .dimensions = {},
13907 .isIgnored = false,
13908 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13909 .numberOfConsumers = 1,
13910 .scale = 0.0f,
13911 .type = TestOperandType::INT32,
13912 .zeroPoint = 0
13913 }, { // op2
13914 .channelQuant = {},
13915 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 165, 165, 165, 165, 61, 61, 61, 61, 61, 61, 61, 61, 22, 22, 22, 22, 22, 22, 22, 22, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0}),
13916 .dimensions = {5, 2, 2, 2},
13917 .isIgnored = false,
13918 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
13919 .numberOfConsumers = 0,
13920 .scale = 0.00390625f,
13921 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13922 .zeroPoint = 0
13923 }, { // op1_new
13924 .channelQuant = {},
13925 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 196, 124, 196, 124, 192, 120, 192, 120, 192, 120, 192, 120, 188, 116, 188, 116, 188, 116, 188, 116, 184, 112, 184, 112, 184, 112, 184, 112, 132, 60, 132, 60, 132, 60, 132, 60}),
13926 .dimensions = {5, 2, 2, 2},
13927 .isIgnored = false,
13928 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13929 .numberOfConsumers = 1,
13930 .scale = 0.25f,
13931 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13932 .zeroPoint = 128
13933 }, { // placeholder85
13934 .channelQuant = {},
13935 .data = TestBuffer::createFromVector<uint8_t>({128}),
13936 .dimensions = {1},
13937 .isIgnored = false,
13938 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13939 .numberOfConsumers = 1,
13940 .scale = 0.25f,
13941 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13942 .zeroPoint = 128
13943 }, { // param103
13944 .channelQuant = {},
13945 .data = TestBuffer::createFromVector<int32_t>({0}),
13946 .dimensions = {},
13947 .isIgnored = false,
13948 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
13949 .numberOfConsumers = 1,
13950 .scale = 0.0f,
13951 .type = TestOperandType::INT32,
13952 .zeroPoint = 0
13953 }},
13954 .operations = {{
13955 .inputs = {4, 5, 6},
13956 .outputs = {0},
13957 .type = TestOperationType::ADD
13958 }, {
13959 .inputs = {0, 1, 2},
13960 .outputs = {3},
13961 .type = TestOperationType::SOFTMAX
13962 }},
13963 .outputIndexes = {3}
13964 },
13965 .minSupportedVersion = TestHalVersion::V1_2,
13966 .referenced = {}
13967 };
13968 return model;
13969 }
13970
13971 const auto dummy_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal());
13972
13973 } // namespace generated_tests::softmax_v1_2
13974
13975 namespace generated_tests::softmax_v1_2 {
13976
get_test_model_axis_quant8_dim4_axis1()13977 const TestModel& get_test_model_axis_quant8_dim4_axis1() {
13978 static TestModel model = {
13979 .expectFailure = false,
13980 .expectedMultinomialDistributionTolerance = 0,
13981 .isRelaxed = false,
13982 .main = { // axis
13983 .inputIndexes = {0},
13984 .operands = {{ // op1
13985 .channelQuant = {},
13986 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60, 196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
13987 .dimensions = {2, 5, 2, 2},
13988 .isIgnored = false,
13989 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
13990 .numberOfConsumers = 1,
13991 .scale = 0.25f,
13992 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
13993 .zeroPoint = 128
13994 }, { // param2
13995 .channelQuant = {},
13996 .data = TestBuffer::createFromVector<float>({1.0f}),
13997 .dimensions = {},
13998 .isIgnored = false,
13999 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14000 .numberOfConsumers = 1,
14001 .scale = 0.0f,
14002 .type = TestOperandType::FLOAT32,
14003 .zeroPoint = 0
14004 }, { // axis
14005 .channelQuant = {},
14006 .data = TestBuffer::createFromVector<int32_t>({1}),
14007 .dimensions = {},
14008 .isIgnored = false,
14009 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14010 .numberOfConsumers = 1,
14011 .scale = 0.0f,
14012 .type = TestOperandType::INT32,
14013 .zeroPoint = 0
14014 }, { // op2
14015 .channelQuant = {},
14016 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0, 165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
14017 .dimensions = {2, 5, 2, 2},
14018 .isIgnored = false,
14019 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14020 .numberOfConsumers = 0,
14021 .scale = 0.00390625f,
14022 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14023 .zeroPoint = 0
14024 }},
14025 .operations = {{
14026 .inputs = {0, 1, 2},
14027 .outputs = {3},
14028 .type = TestOperationType::SOFTMAX
14029 }},
14030 .outputIndexes = {3}
14031 },
14032 .minSupportedVersion = TestHalVersion::V1_2,
14033 .referenced = {}
14034 };
14035 return model;
14036 }
14037
14038 const auto dummy_test_model_axis_quant8_dim4_axis1 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1", get_test_model_axis_quant8_dim4_axis1());
14039
14040 } // namespace generated_tests::softmax_v1_2
14041
14042 namespace generated_tests::softmax_v1_2 {
14043
get_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal()14044 const TestModel& get_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal() {
14045 static TestModel model = {
14046 .expectFailure = false,
14047 .expectedMultinomialDistributionTolerance = 0,
14048 .isRelaxed = false,
14049 .main = { // axis
14050 .inputIndexes = {4},
14051 .operands = {{ // op1
14052 .channelQuant = {},
14053 .data = TestBuffer::createFromVector<uint8_t>({}),
14054 .dimensions = {2, 5, 2, 2},
14055 .isIgnored = false,
14056 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
14057 .numberOfConsumers = 1,
14058 .scale = 0.25f,
14059 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14060 .zeroPoint = 128
14061 }, { // param2
14062 .channelQuant = {},
14063 .data = TestBuffer::createFromVector<float>({1.0f}),
14064 .dimensions = {},
14065 .isIgnored = false,
14066 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14067 .numberOfConsumers = 1,
14068 .scale = 0.0f,
14069 .type = TestOperandType::FLOAT32,
14070 .zeroPoint = 0
14071 }, { // axis
14072 .channelQuant = {},
14073 .data = TestBuffer::createFromVector<int32_t>({1}),
14074 .dimensions = {},
14075 .isIgnored = false,
14076 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14077 .numberOfConsumers = 1,
14078 .scale = 0.0f,
14079 .type = TestOperandType::INT32,
14080 .zeroPoint = 0
14081 }, { // op2
14082 .channelQuant = {},
14083 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0, 165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
14084 .dimensions = {2, 5, 2, 2},
14085 .isIgnored = false,
14086 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14087 .numberOfConsumers = 0,
14088 .scale = 0.00390625f,
14089 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14090 .zeroPoint = 0
14091 }, { // op1_new
14092 .channelQuant = {},
14093 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60, 196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
14094 .dimensions = {2, 5, 2, 2},
14095 .isIgnored = false,
14096 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14097 .numberOfConsumers = 1,
14098 .scale = 0.25f,
14099 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14100 .zeroPoint = 128
14101 }, { // placeholder86
14102 .channelQuant = {},
14103 .data = TestBuffer::createFromVector<uint8_t>({128}),
14104 .dimensions = {1},
14105 .isIgnored = false,
14106 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14107 .numberOfConsumers = 1,
14108 .scale = 0.25f,
14109 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14110 .zeroPoint = 128
14111 }, { // param104
14112 .channelQuant = {},
14113 .data = TestBuffer::createFromVector<int32_t>({0}),
14114 .dimensions = {},
14115 .isIgnored = false,
14116 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14117 .numberOfConsumers = 1,
14118 .scale = 0.0f,
14119 .type = TestOperandType::INT32,
14120 .zeroPoint = 0
14121 }},
14122 .operations = {{
14123 .inputs = {4, 5, 6},
14124 .outputs = {0},
14125 .type = TestOperationType::ADD
14126 }, {
14127 .inputs = {0, 1, 2},
14128 .outputs = {3},
14129 .type = TestOperationType::SOFTMAX
14130 }},
14131 .outputIndexes = {3}
14132 },
14133 .minSupportedVersion = TestHalVersion::V1_2,
14134 .referenced = {}
14135 };
14136 return model;
14137 }
14138
14139 const auto dummy_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal());
14140
14141 } // namespace generated_tests::softmax_v1_2
14142
14143 namespace generated_tests::softmax_v1_2 {
14144
get_test_model_axis_quant8_dim4_axis1_neg()14145 const TestModel& get_test_model_axis_quant8_dim4_axis1_neg() {
14146 static TestModel model = {
14147 .expectFailure = false,
14148 .expectedMultinomialDistributionTolerance = 0,
14149 .isRelaxed = false,
14150 .main = { // axis
14151 .inputIndexes = {0},
14152 .operands = {{ // op1
14153 .channelQuant = {},
14154 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60, 196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
14155 .dimensions = {2, 5, 2, 2},
14156 .isIgnored = false,
14157 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14158 .numberOfConsumers = 1,
14159 .scale = 0.25f,
14160 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14161 .zeroPoint = 128
14162 }, { // param2
14163 .channelQuant = {},
14164 .data = TestBuffer::createFromVector<float>({1.0f}),
14165 .dimensions = {},
14166 .isIgnored = false,
14167 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14168 .numberOfConsumers = 1,
14169 .scale = 0.0f,
14170 .type = TestOperandType::FLOAT32,
14171 .zeroPoint = 0
14172 }, { // axis
14173 .channelQuant = {},
14174 .data = TestBuffer::createFromVector<int32_t>({-3}),
14175 .dimensions = {},
14176 .isIgnored = false,
14177 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14178 .numberOfConsumers = 1,
14179 .scale = 0.0f,
14180 .type = TestOperandType::INT32,
14181 .zeroPoint = 0
14182 }, { // op2
14183 .channelQuant = {},
14184 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0, 165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
14185 .dimensions = {2, 5, 2, 2},
14186 .isIgnored = false,
14187 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14188 .numberOfConsumers = 0,
14189 .scale = 0.00390625f,
14190 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14191 .zeroPoint = 0
14192 }},
14193 .operations = {{
14194 .inputs = {0, 1, 2},
14195 .outputs = {3},
14196 .type = TestOperationType::SOFTMAX
14197 }},
14198 .outputIndexes = {3}
14199 },
14200 .minSupportedVersion = TestHalVersion::V1_2,
14201 .referenced = {}
14202 };
14203 return model;
14204 }
14205
14206 const auto dummy_test_model_axis_quant8_dim4_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1_neg", get_test_model_axis_quant8_dim4_axis1_neg());
14207
14208 } // namespace generated_tests::softmax_v1_2
14209
14210 namespace generated_tests::softmax_v1_2 {
14211
get_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal()14212 const TestModel& get_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal() {
14213 static TestModel model = {
14214 .expectFailure = false,
14215 .expectedMultinomialDistributionTolerance = 0,
14216 .isRelaxed = false,
14217 .main = { // axis
14218 .inputIndexes = {4},
14219 .operands = {{ // op1
14220 .channelQuant = {},
14221 .data = TestBuffer::createFromVector<uint8_t>({}),
14222 .dimensions = {2, 5, 2, 2},
14223 .isIgnored = false,
14224 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
14225 .numberOfConsumers = 1,
14226 .scale = 0.25f,
14227 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14228 .zeroPoint = 128
14229 }, { // param2
14230 .channelQuant = {},
14231 .data = TestBuffer::createFromVector<float>({1.0f}),
14232 .dimensions = {},
14233 .isIgnored = false,
14234 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14235 .numberOfConsumers = 1,
14236 .scale = 0.0f,
14237 .type = TestOperandType::FLOAT32,
14238 .zeroPoint = 0
14239 }, { // axis
14240 .channelQuant = {},
14241 .data = TestBuffer::createFromVector<int32_t>({-3}),
14242 .dimensions = {},
14243 .isIgnored = false,
14244 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14245 .numberOfConsumers = 1,
14246 .scale = 0.0f,
14247 .type = TestOperandType::INT32,
14248 .zeroPoint = 0
14249 }, { // op2
14250 .channelQuant = {},
14251 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0, 165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
14252 .dimensions = {2, 5, 2, 2},
14253 .isIgnored = false,
14254 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14255 .numberOfConsumers = 0,
14256 .scale = 0.00390625f,
14257 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14258 .zeroPoint = 0
14259 }, { // op1_new
14260 .channelQuant = {},
14261 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60, 196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
14262 .dimensions = {2, 5, 2, 2},
14263 .isIgnored = false,
14264 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14265 .numberOfConsumers = 1,
14266 .scale = 0.25f,
14267 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14268 .zeroPoint = 128
14269 }, { // placeholder87
14270 .channelQuant = {},
14271 .data = TestBuffer::createFromVector<uint8_t>({128}),
14272 .dimensions = {1},
14273 .isIgnored = false,
14274 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14275 .numberOfConsumers = 1,
14276 .scale = 0.25f,
14277 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14278 .zeroPoint = 128
14279 }, { // param105
14280 .channelQuant = {},
14281 .data = TestBuffer::createFromVector<int32_t>({0}),
14282 .dimensions = {},
14283 .isIgnored = false,
14284 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14285 .numberOfConsumers = 1,
14286 .scale = 0.0f,
14287 .type = TestOperandType::INT32,
14288 .zeroPoint = 0
14289 }},
14290 .operations = {{
14291 .inputs = {4, 5, 6},
14292 .outputs = {0},
14293 .type = TestOperationType::ADD
14294 }, {
14295 .inputs = {0, 1, 2},
14296 .outputs = {3},
14297 .type = TestOperationType::SOFTMAX
14298 }},
14299 .outputIndexes = {3}
14300 },
14301 .minSupportedVersion = TestHalVersion::V1_2,
14302 .referenced = {}
14303 };
14304 return model;
14305 }
14306
14307 const auto dummy_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal());
14308
14309 } // namespace generated_tests::softmax_v1_2
14310
14311 namespace generated_tests::softmax_v1_2 {
14312
get_test_model_axis_quant8_dim4_axis2()14313 const TestModel& get_test_model_axis_quant8_dim4_axis2() {
14314 static TestModel model = {
14315 .expectFailure = false,
14316 .expectedMultinomialDistributionTolerance = 0,
14317 .isRelaxed = false,
14318 .main = { // axis
14319 .inputIndexes = {0},
14320 .operands = {{ // op1
14321 .channelQuant = {},
14322 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
14323 .dimensions = {2, 2, 5, 2},
14324 .isIgnored = false,
14325 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14326 .numberOfConsumers = 1,
14327 .scale = 0.25f,
14328 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14329 .zeroPoint = 128
14330 }, { // param2
14331 .channelQuant = {},
14332 .data = TestBuffer::createFromVector<float>({1.0f}),
14333 .dimensions = {},
14334 .isIgnored = false,
14335 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14336 .numberOfConsumers = 1,
14337 .scale = 0.0f,
14338 .type = TestOperandType::FLOAT32,
14339 .zeroPoint = 0
14340 }, { // axis
14341 .channelQuant = {},
14342 .data = TestBuffer::createFromVector<int32_t>({2}),
14343 .dimensions = {},
14344 .isIgnored = false,
14345 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14346 .numberOfConsumers = 1,
14347 .scale = 0.0f,
14348 .type = TestOperandType::INT32,
14349 .zeroPoint = 0
14350 }, { // op2
14351 .channelQuant = {},
14352 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
14353 .dimensions = {2, 2, 5, 2},
14354 .isIgnored = false,
14355 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14356 .numberOfConsumers = 0,
14357 .scale = 0.00390625f,
14358 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14359 .zeroPoint = 0
14360 }},
14361 .operations = {{
14362 .inputs = {0, 1, 2},
14363 .outputs = {3},
14364 .type = TestOperationType::SOFTMAX
14365 }},
14366 .outputIndexes = {3}
14367 },
14368 .minSupportedVersion = TestHalVersion::V1_2,
14369 .referenced = {}
14370 };
14371 return model;
14372 }
14373
14374 const auto dummy_test_model_axis_quant8_dim4_axis2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2", get_test_model_axis_quant8_dim4_axis2());
14375
14376 } // namespace generated_tests::softmax_v1_2
14377
14378 namespace generated_tests::softmax_v1_2 {
14379
get_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal()14380 const TestModel& get_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal() {
14381 static TestModel model = {
14382 .expectFailure = false,
14383 .expectedMultinomialDistributionTolerance = 0,
14384 .isRelaxed = false,
14385 .main = { // axis
14386 .inputIndexes = {4},
14387 .operands = {{ // op1
14388 .channelQuant = {},
14389 .data = TestBuffer::createFromVector<uint8_t>({}),
14390 .dimensions = {2, 2, 5, 2},
14391 .isIgnored = false,
14392 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
14393 .numberOfConsumers = 1,
14394 .scale = 0.25f,
14395 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14396 .zeroPoint = 128
14397 }, { // param2
14398 .channelQuant = {},
14399 .data = TestBuffer::createFromVector<float>({1.0f}),
14400 .dimensions = {},
14401 .isIgnored = false,
14402 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14403 .numberOfConsumers = 1,
14404 .scale = 0.0f,
14405 .type = TestOperandType::FLOAT32,
14406 .zeroPoint = 0
14407 }, { // axis
14408 .channelQuant = {},
14409 .data = TestBuffer::createFromVector<int32_t>({2}),
14410 .dimensions = {},
14411 .isIgnored = false,
14412 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14413 .numberOfConsumers = 1,
14414 .scale = 0.0f,
14415 .type = TestOperandType::INT32,
14416 .zeroPoint = 0
14417 }, { // op2
14418 .channelQuant = {},
14419 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
14420 .dimensions = {2, 2, 5, 2},
14421 .isIgnored = false,
14422 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14423 .numberOfConsumers = 0,
14424 .scale = 0.00390625f,
14425 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14426 .zeroPoint = 0
14427 }, { // op1_new
14428 .channelQuant = {},
14429 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
14430 .dimensions = {2, 2, 5, 2},
14431 .isIgnored = false,
14432 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14433 .numberOfConsumers = 1,
14434 .scale = 0.25f,
14435 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14436 .zeroPoint = 128
14437 }, { // placeholder88
14438 .channelQuant = {},
14439 .data = TestBuffer::createFromVector<uint8_t>({128}),
14440 .dimensions = {1},
14441 .isIgnored = false,
14442 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14443 .numberOfConsumers = 1,
14444 .scale = 0.25f,
14445 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14446 .zeroPoint = 128
14447 }, { // param106
14448 .channelQuant = {},
14449 .data = TestBuffer::createFromVector<int32_t>({0}),
14450 .dimensions = {},
14451 .isIgnored = false,
14452 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14453 .numberOfConsumers = 1,
14454 .scale = 0.0f,
14455 .type = TestOperandType::INT32,
14456 .zeroPoint = 0
14457 }},
14458 .operations = {{
14459 .inputs = {4, 5, 6},
14460 .outputs = {0},
14461 .type = TestOperationType::ADD
14462 }, {
14463 .inputs = {0, 1, 2},
14464 .outputs = {3},
14465 .type = TestOperationType::SOFTMAX
14466 }},
14467 .outputIndexes = {3}
14468 },
14469 .minSupportedVersion = TestHalVersion::V1_2,
14470 .referenced = {}
14471 };
14472 return model;
14473 }
14474
14475 const auto dummy_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal());
14476
14477 } // namespace generated_tests::softmax_v1_2
14478
14479 namespace generated_tests::softmax_v1_2 {
14480
get_test_model_axis_quant8_dim4_axis2_neg()14481 const TestModel& get_test_model_axis_quant8_dim4_axis2_neg() {
14482 static TestModel model = {
14483 .expectFailure = false,
14484 .expectedMultinomialDistributionTolerance = 0,
14485 .isRelaxed = false,
14486 .main = { // axis
14487 .inputIndexes = {0},
14488 .operands = {{ // op1
14489 .channelQuant = {},
14490 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
14491 .dimensions = {2, 2, 5, 2},
14492 .isIgnored = false,
14493 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14494 .numberOfConsumers = 1,
14495 .scale = 0.25f,
14496 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14497 .zeroPoint = 128
14498 }, { // param2
14499 .channelQuant = {},
14500 .data = TestBuffer::createFromVector<float>({1.0f}),
14501 .dimensions = {},
14502 .isIgnored = false,
14503 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14504 .numberOfConsumers = 1,
14505 .scale = 0.0f,
14506 .type = TestOperandType::FLOAT32,
14507 .zeroPoint = 0
14508 }, { // axis
14509 .channelQuant = {},
14510 .data = TestBuffer::createFromVector<int32_t>({-2}),
14511 .dimensions = {},
14512 .isIgnored = false,
14513 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14514 .numberOfConsumers = 1,
14515 .scale = 0.0f,
14516 .type = TestOperandType::INT32,
14517 .zeroPoint = 0
14518 }, { // op2
14519 .channelQuant = {},
14520 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
14521 .dimensions = {2, 2, 5, 2},
14522 .isIgnored = false,
14523 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14524 .numberOfConsumers = 0,
14525 .scale = 0.00390625f,
14526 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14527 .zeroPoint = 0
14528 }},
14529 .operations = {{
14530 .inputs = {0, 1, 2},
14531 .outputs = {3},
14532 .type = TestOperationType::SOFTMAX
14533 }},
14534 .outputIndexes = {3}
14535 },
14536 .minSupportedVersion = TestHalVersion::V1_2,
14537 .referenced = {}
14538 };
14539 return model;
14540 }
14541
14542 const auto dummy_test_model_axis_quant8_dim4_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2_neg", get_test_model_axis_quant8_dim4_axis2_neg());
14543
14544 } // namespace generated_tests::softmax_v1_2
14545
14546 namespace generated_tests::softmax_v1_2 {
14547
get_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal()14548 const TestModel& get_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal() {
14549 static TestModel model = {
14550 .expectFailure = false,
14551 .expectedMultinomialDistributionTolerance = 0,
14552 .isRelaxed = false,
14553 .main = { // axis
14554 .inputIndexes = {4},
14555 .operands = {{ // op1
14556 .channelQuant = {},
14557 .data = TestBuffer::createFromVector<uint8_t>({}),
14558 .dimensions = {2, 2, 5, 2},
14559 .isIgnored = false,
14560 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
14561 .numberOfConsumers = 1,
14562 .scale = 0.25f,
14563 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14564 .zeroPoint = 128
14565 }, { // param2
14566 .channelQuant = {},
14567 .data = TestBuffer::createFromVector<float>({1.0f}),
14568 .dimensions = {},
14569 .isIgnored = false,
14570 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14571 .numberOfConsumers = 1,
14572 .scale = 0.0f,
14573 .type = TestOperandType::FLOAT32,
14574 .zeroPoint = 0
14575 }, { // axis
14576 .channelQuant = {},
14577 .data = TestBuffer::createFromVector<int32_t>({-2}),
14578 .dimensions = {},
14579 .isIgnored = false,
14580 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14581 .numberOfConsumers = 1,
14582 .scale = 0.0f,
14583 .type = TestOperandType::INT32,
14584 .zeroPoint = 0
14585 }, { // op2
14586 .channelQuant = {},
14587 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
14588 .dimensions = {2, 2, 5, 2},
14589 .isIgnored = false,
14590 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14591 .numberOfConsumers = 0,
14592 .scale = 0.00390625f,
14593 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14594 .zeroPoint = 0
14595 }, { // op1_new
14596 .channelQuant = {},
14597 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
14598 .dimensions = {2, 2, 5, 2},
14599 .isIgnored = false,
14600 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14601 .numberOfConsumers = 1,
14602 .scale = 0.25f,
14603 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14604 .zeroPoint = 128
14605 }, { // placeholder89
14606 .channelQuant = {},
14607 .data = TestBuffer::createFromVector<uint8_t>({128}),
14608 .dimensions = {1},
14609 .isIgnored = false,
14610 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14611 .numberOfConsumers = 1,
14612 .scale = 0.25f,
14613 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14614 .zeroPoint = 128
14615 }, { // param107
14616 .channelQuant = {},
14617 .data = TestBuffer::createFromVector<int32_t>({0}),
14618 .dimensions = {},
14619 .isIgnored = false,
14620 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14621 .numberOfConsumers = 1,
14622 .scale = 0.0f,
14623 .type = TestOperandType::INT32,
14624 .zeroPoint = 0
14625 }},
14626 .operations = {{
14627 .inputs = {4, 5, 6},
14628 .outputs = {0},
14629 .type = TestOperationType::ADD
14630 }, {
14631 .inputs = {0, 1, 2},
14632 .outputs = {3},
14633 .type = TestOperationType::SOFTMAX
14634 }},
14635 .outputIndexes = {3}
14636 },
14637 .minSupportedVersion = TestHalVersion::V1_2,
14638 .referenced = {}
14639 };
14640 return model;
14641 }
14642
14643 const auto dummy_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal());
14644
14645 } // namespace generated_tests::softmax_v1_2
14646
14647 namespace generated_tests::softmax_v1_2 {
14648
get_test_model_axis_quant8_dim4_axis3()14649 const TestModel& get_test_model_axis_quant8_dim4_axis3() {
14650 static TestModel model = {
14651 .expectFailure = false,
14652 .expectedMultinomialDistributionTolerance = 0,
14653 .isRelaxed = false,
14654 .main = { // axis
14655 .inputIndexes = {0},
14656 .operands = {{ // op1
14657 .channelQuant = {},
14658 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
14659 .dimensions = {2, 2, 2, 5},
14660 .isIgnored = false,
14661 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14662 .numberOfConsumers = 1,
14663 .scale = 0.25f,
14664 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14665 .zeroPoint = 128
14666 }, { // param2
14667 .channelQuant = {},
14668 .data = TestBuffer::createFromVector<float>({1.0f}),
14669 .dimensions = {},
14670 .isIgnored = false,
14671 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14672 .numberOfConsumers = 1,
14673 .scale = 0.0f,
14674 .type = TestOperandType::FLOAT32,
14675 .zeroPoint = 0
14676 }, { // axis
14677 .channelQuant = {},
14678 .data = TestBuffer::createFromVector<int32_t>({3}),
14679 .dimensions = {},
14680 .isIgnored = false,
14681 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14682 .numberOfConsumers = 1,
14683 .scale = 0.0f,
14684 .type = TestOperandType::INT32,
14685 .zeroPoint = 0
14686 }, { // op2
14687 .channelQuant = {},
14688 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
14689 .dimensions = {2, 2, 2, 5},
14690 .isIgnored = false,
14691 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14692 .numberOfConsumers = 0,
14693 .scale = 0.00390625f,
14694 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14695 .zeroPoint = 0
14696 }},
14697 .operations = {{
14698 .inputs = {0, 1, 2},
14699 .outputs = {3},
14700 .type = TestOperationType::SOFTMAX
14701 }},
14702 .outputIndexes = {3}
14703 },
14704 .minSupportedVersion = TestHalVersion::V1_2,
14705 .referenced = {}
14706 };
14707 return model;
14708 }
14709
14710 const auto dummy_test_model_axis_quant8_dim4_axis3 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3", get_test_model_axis_quant8_dim4_axis3());
14711
14712 } // namespace generated_tests::softmax_v1_2
14713
14714 namespace generated_tests::softmax_v1_2 {
14715
get_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal()14716 const TestModel& get_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal() {
14717 static TestModel model = {
14718 .expectFailure = false,
14719 .expectedMultinomialDistributionTolerance = 0,
14720 .isRelaxed = false,
14721 .main = { // axis
14722 .inputIndexes = {4},
14723 .operands = {{ // op1
14724 .channelQuant = {},
14725 .data = TestBuffer::createFromVector<uint8_t>({}),
14726 .dimensions = {2, 2, 2, 5},
14727 .isIgnored = false,
14728 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
14729 .numberOfConsumers = 1,
14730 .scale = 0.25f,
14731 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14732 .zeroPoint = 128
14733 }, { // param2
14734 .channelQuant = {},
14735 .data = TestBuffer::createFromVector<float>({1.0f}),
14736 .dimensions = {},
14737 .isIgnored = false,
14738 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14739 .numberOfConsumers = 1,
14740 .scale = 0.0f,
14741 .type = TestOperandType::FLOAT32,
14742 .zeroPoint = 0
14743 }, { // axis
14744 .channelQuant = {},
14745 .data = TestBuffer::createFromVector<int32_t>({3}),
14746 .dimensions = {},
14747 .isIgnored = false,
14748 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14749 .numberOfConsumers = 1,
14750 .scale = 0.0f,
14751 .type = TestOperandType::INT32,
14752 .zeroPoint = 0
14753 }, { // op2
14754 .channelQuant = {},
14755 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
14756 .dimensions = {2, 2, 2, 5},
14757 .isIgnored = false,
14758 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14759 .numberOfConsumers = 0,
14760 .scale = 0.00390625f,
14761 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14762 .zeroPoint = 0
14763 }, { // op1_new
14764 .channelQuant = {},
14765 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
14766 .dimensions = {2, 2, 2, 5},
14767 .isIgnored = false,
14768 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14769 .numberOfConsumers = 1,
14770 .scale = 0.25f,
14771 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14772 .zeroPoint = 128
14773 }, { // placeholder90
14774 .channelQuant = {},
14775 .data = TestBuffer::createFromVector<uint8_t>({128}),
14776 .dimensions = {1},
14777 .isIgnored = false,
14778 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14779 .numberOfConsumers = 1,
14780 .scale = 0.25f,
14781 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14782 .zeroPoint = 128
14783 }, { // param108
14784 .channelQuant = {},
14785 .data = TestBuffer::createFromVector<int32_t>({0}),
14786 .dimensions = {},
14787 .isIgnored = false,
14788 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14789 .numberOfConsumers = 1,
14790 .scale = 0.0f,
14791 .type = TestOperandType::INT32,
14792 .zeroPoint = 0
14793 }},
14794 .operations = {{
14795 .inputs = {4, 5, 6},
14796 .outputs = {0},
14797 .type = TestOperationType::ADD
14798 }, {
14799 .inputs = {0, 1, 2},
14800 .outputs = {3},
14801 .type = TestOperationType::SOFTMAX
14802 }},
14803 .outputIndexes = {3}
14804 },
14805 .minSupportedVersion = TestHalVersion::V1_2,
14806 .referenced = {}
14807 };
14808 return model;
14809 }
14810
14811 const auto dummy_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal());
14812
14813 } // namespace generated_tests::softmax_v1_2
14814
14815 namespace generated_tests::softmax_v1_2 {
14816
get_test_model_axis_quant8_dim4_axis3_neg()14817 const TestModel& get_test_model_axis_quant8_dim4_axis3_neg() {
14818 static TestModel model = {
14819 .expectFailure = false,
14820 .expectedMultinomialDistributionTolerance = 0,
14821 .isRelaxed = false,
14822 .main = { // axis
14823 .inputIndexes = {0},
14824 .operands = {{ // op1
14825 .channelQuant = {},
14826 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
14827 .dimensions = {2, 2, 2, 5},
14828 .isIgnored = false,
14829 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14830 .numberOfConsumers = 1,
14831 .scale = 0.25f,
14832 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14833 .zeroPoint = 128
14834 }, { // param2
14835 .channelQuant = {},
14836 .data = TestBuffer::createFromVector<float>({1.0f}),
14837 .dimensions = {},
14838 .isIgnored = false,
14839 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14840 .numberOfConsumers = 1,
14841 .scale = 0.0f,
14842 .type = TestOperandType::FLOAT32,
14843 .zeroPoint = 0
14844 }, { // axis
14845 .channelQuant = {},
14846 .data = TestBuffer::createFromVector<int32_t>({-1}),
14847 .dimensions = {},
14848 .isIgnored = false,
14849 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14850 .numberOfConsumers = 1,
14851 .scale = 0.0f,
14852 .type = TestOperandType::INT32,
14853 .zeroPoint = 0
14854 }, { // op2
14855 .channelQuant = {},
14856 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
14857 .dimensions = {2, 2, 2, 5},
14858 .isIgnored = false,
14859 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14860 .numberOfConsumers = 0,
14861 .scale = 0.00390625f,
14862 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14863 .zeroPoint = 0
14864 }},
14865 .operations = {{
14866 .inputs = {0, 1, 2},
14867 .outputs = {3},
14868 .type = TestOperationType::SOFTMAX
14869 }},
14870 .outputIndexes = {3}
14871 },
14872 .minSupportedVersion = TestHalVersion::V1_0,
14873 .referenced = {}
14874 };
14875 return model;
14876 }
14877
14878 const auto dummy_test_model_axis_quant8_dim4_axis3_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3_neg", get_test_model_axis_quant8_dim4_axis3_neg());
14879
14880 } // namespace generated_tests::softmax_v1_2
14881
14882 namespace generated_tests::softmax_v1_2 {
14883
get_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal()14884 const TestModel& get_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal() {
14885 static TestModel model = {
14886 .expectFailure = false,
14887 .expectedMultinomialDistributionTolerance = 0,
14888 .isRelaxed = false,
14889 .main = { // axis
14890 .inputIndexes = {4},
14891 .operands = {{ // op1
14892 .channelQuant = {},
14893 .data = TestBuffer::createFromVector<uint8_t>({}),
14894 .dimensions = {2, 2, 2, 5},
14895 .isIgnored = false,
14896 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
14897 .numberOfConsumers = 1,
14898 .scale = 0.25f,
14899 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14900 .zeroPoint = 128
14901 }, { // param2
14902 .channelQuant = {},
14903 .data = TestBuffer::createFromVector<float>({1.0f}),
14904 .dimensions = {},
14905 .isIgnored = false,
14906 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14907 .numberOfConsumers = 1,
14908 .scale = 0.0f,
14909 .type = TestOperandType::FLOAT32,
14910 .zeroPoint = 0
14911 }, { // axis
14912 .channelQuant = {},
14913 .data = TestBuffer::createFromVector<int32_t>({-1}),
14914 .dimensions = {},
14915 .isIgnored = false,
14916 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14917 .numberOfConsumers = 1,
14918 .scale = 0.0f,
14919 .type = TestOperandType::INT32,
14920 .zeroPoint = 0
14921 }, { // op2
14922 .channelQuant = {},
14923 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
14924 .dimensions = {2, 2, 2, 5},
14925 .isIgnored = false,
14926 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
14927 .numberOfConsumers = 0,
14928 .scale = 0.00390625f,
14929 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14930 .zeroPoint = 0
14931 }, { // op1_new
14932 .channelQuant = {},
14933 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
14934 .dimensions = {2, 2, 2, 5},
14935 .isIgnored = false,
14936 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14937 .numberOfConsumers = 1,
14938 .scale = 0.25f,
14939 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14940 .zeroPoint = 128
14941 }, { // placeholder91
14942 .channelQuant = {},
14943 .data = TestBuffer::createFromVector<uint8_t>({128}),
14944 .dimensions = {1},
14945 .isIgnored = false,
14946 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14947 .numberOfConsumers = 1,
14948 .scale = 0.25f,
14949 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
14950 .zeroPoint = 128
14951 }, { // param109
14952 .channelQuant = {},
14953 .data = TestBuffer::createFromVector<int32_t>({0}),
14954 .dimensions = {},
14955 .isIgnored = false,
14956 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
14957 .numberOfConsumers = 1,
14958 .scale = 0.0f,
14959 .type = TestOperandType::INT32,
14960 .zeroPoint = 0
14961 }},
14962 .operations = {{
14963 .inputs = {4, 5, 6},
14964 .outputs = {0},
14965 .type = TestOperationType::ADD
14966 }, {
14967 .inputs = {0, 1, 2},
14968 .outputs = {3},
14969 .type = TestOperationType::SOFTMAX
14970 }},
14971 .outputIndexes = {3}
14972 },
14973 .minSupportedVersion = TestHalVersion::V1_0,
14974 .referenced = {}
14975 };
14976 return model;
14977 }
14978
14979 const auto dummy_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal());
14980
14981 } // namespace generated_tests::softmax_v1_2
14982
14983 namespace generated_tests::softmax_v1_2 {
14984
get_test_model_axis_quant8_dim3_axis0()14985 const TestModel& get_test_model_axis_quant8_dim3_axis0() {
14986 static TestModel model = {
14987 .expectFailure = false,
14988 .expectedMultinomialDistributionTolerance = 0,
14989 .isRelaxed = false,
14990 .main = { // axis
14991 .inputIndexes = {0},
14992 .operands = {{ // op1
14993 .channelQuant = {},
14994 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
14995 .dimensions = {5, 2, 2},
14996 .isIgnored = false,
14997 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
14998 .numberOfConsumers = 1,
14999 .scale = 0.25f,
15000 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15001 .zeroPoint = 128
15002 }, { // param2
15003 .channelQuant = {},
15004 .data = TestBuffer::createFromVector<float>({1.0f}),
15005 .dimensions = {},
15006 .isIgnored = false,
15007 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15008 .numberOfConsumers = 1,
15009 .scale = 0.0f,
15010 .type = TestOperandType::FLOAT32,
15011 .zeroPoint = 0
15012 }, { // axis
15013 .channelQuant = {},
15014 .data = TestBuffer::createFromVector<int32_t>({0}),
15015 .dimensions = {},
15016 .isIgnored = false,
15017 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15018 .numberOfConsumers = 1,
15019 .scale = 0.0f,
15020 .type = TestOperandType::INT32,
15021 .zeroPoint = 0
15022 }, { // op2
15023 .channelQuant = {},
15024 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
15025 .dimensions = {5, 2, 2},
15026 .isIgnored = false,
15027 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15028 .numberOfConsumers = 0,
15029 .scale = 0.00390625f,
15030 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15031 .zeroPoint = 0
15032 }},
15033 .operations = {{
15034 .inputs = {0, 1, 2},
15035 .outputs = {3},
15036 .type = TestOperationType::SOFTMAX
15037 }},
15038 .outputIndexes = {3}
15039 },
15040 .minSupportedVersion = TestHalVersion::V1_2,
15041 .referenced = {}
15042 };
15043 return model;
15044 }
15045
15046 const auto dummy_test_model_axis_quant8_dim3_axis0 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0", get_test_model_axis_quant8_dim3_axis0());
15047
15048 } // namespace generated_tests::softmax_v1_2
15049
15050 namespace generated_tests::softmax_v1_2 {
15051
get_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal()15052 const TestModel& get_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal() {
15053 static TestModel model = {
15054 .expectFailure = false,
15055 .expectedMultinomialDistributionTolerance = 0,
15056 .isRelaxed = false,
15057 .main = { // axis
15058 .inputIndexes = {4},
15059 .operands = {{ // op1
15060 .channelQuant = {},
15061 .data = TestBuffer::createFromVector<uint8_t>({}),
15062 .dimensions = {5, 2, 2},
15063 .isIgnored = false,
15064 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
15065 .numberOfConsumers = 1,
15066 .scale = 0.25f,
15067 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15068 .zeroPoint = 128
15069 }, { // param2
15070 .channelQuant = {},
15071 .data = TestBuffer::createFromVector<float>({1.0f}),
15072 .dimensions = {},
15073 .isIgnored = false,
15074 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15075 .numberOfConsumers = 1,
15076 .scale = 0.0f,
15077 .type = TestOperandType::FLOAT32,
15078 .zeroPoint = 0
15079 }, { // axis
15080 .channelQuant = {},
15081 .data = TestBuffer::createFromVector<int32_t>({0}),
15082 .dimensions = {},
15083 .isIgnored = false,
15084 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15085 .numberOfConsumers = 1,
15086 .scale = 0.0f,
15087 .type = TestOperandType::INT32,
15088 .zeroPoint = 0
15089 }, { // op2
15090 .channelQuant = {},
15091 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
15092 .dimensions = {5, 2, 2},
15093 .isIgnored = false,
15094 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15095 .numberOfConsumers = 0,
15096 .scale = 0.00390625f,
15097 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15098 .zeroPoint = 0
15099 }, { // op1_new
15100 .channelQuant = {},
15101 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
15102 .dimensions = {5, 2, 2},
15103 .isIgnored = false,
15104 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15105 .numberOfConsumers = 1,
15106 .scale = 0.25f,
15107 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15108 .zeroPoint = 128
15109 }, { // placeholder92
15110 .channelQuant = {},
15111 .data = TestBuffer::createFromVector<uint8_t>({128}),
15112 .dimensions = {1},
15113 .isIgnored = false,
15114 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15115 .numberOfConsumers = 1,
15116 .scale = 0.25f,
15117 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15118 .zeroPoint = 128
15119 }, { // param110
15120 .channelQuant = {},
15121 .data = TestBuffer::createFromVector<int32_t>({0}),
15122 .dimensions = {},
15123 .isIgnored = false,
15124 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15125 .numberOfConsumers = 1,
15126 .scale = 0.0f,
15127 .type = TestOperandType::INT32,
15128 .zeroPoint = 0
15129 }},
15130 .operations = {{
15131 .inputs = {4, 5, 6},
15132 .outputs = {0},
15133 .type = TestOperationType::ADD
15134 }, {
15135 .inputs = {0, 1, 2},
15136 .outputs = {3},
15137 .type = TestOperationType::SOFTMAX
15138 }},
15139 .outputIndexes = {3}
15140 },
15141 .minSupportedVersion = TestHalVersion::V1_2,
15142 .referenced = {}
15143 };
15144 return model;
15145 }
15146
15147 const auto dummy_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0_all_inputs_as_internal", get_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal());
15148
15149 } // namespace generated_tests::softmax_v1_2
15150
15151 namespace generated_tests::softmax_v1_2 {
15152
get_test_model_axis_quant8_dim3_axis0_neg()15153 const TestModel& get_test_model_axis_quant8_dim3_axis0_neg() {
15154 static TestModel model = {
15155 .expectFailure = false,
15156 .expectedMultinomialDistributionTolerance = 0,
15157 .isRelaxed = false,
15158 .main = { // axis
15159 .inputIndexes = {0},
15160 .operands = {{ // op1
15161 .channelQuant = {},
15162 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
15163 .dimensions = {5, 2, 2},
15164 .isIgnored = false,
15165 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15166 .numberOfConsumers = 1,
15167 .scale = 0.25f,
15168 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15169 .zeroPoint = 128
15170 }, { // param2
15171 .channelQuant = {},
15172 .data = TestBuffer::createFromVector<float>({1.0f}),
15173 .dimensions = {},
15174 .isIgnored = false,
15175 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15176 .numberOfConsumers = 1,
15177 .scale = 0.0f,
15178 .type = TestOperandType::FLOAT32,
15179 .zeroPoint = 0
15180 }, { // axis
15181 .channelQuant = {},
15182 .data = TestBuffer::createFromVector<int32_t>({-3}),
15183 .dimensions = {},
15184 .isIgnored = false,
15185 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15186 .numberOfConsumers = 1,
15187 .scale = 0.0f,
15188 .type = TestOperandType::INT32,
15189 .zeroPoint = 0
15190 }, { // op2
15191 .channelQuant = {},
15192 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
15193 .dimensions = {5, 2, 2},
15194 .isIgnored = false,
15195 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15196 .numberOfConsumers = 0,
15197 .scale = 0.00390625f,
15198 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15199 .zeroPoint = 0
15200 }},
15201 .operations = {{
15202 .inputs = {0, 1, 2},
15203 .outputs = {3},
15204 .type = TestOperationType::SOFTMAX
15205 }},
15206 .outputIndexes = {3}
15207 },
15208 .minSupportedVersion = TestHalVersion::V1_2,
15209 .referenced = {}
15210 };
15211 return model;
15212 }
15213
15214 const auto dummy_test_model_axis_quant8_dim3_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0_neg", get_test_model_axis_quant8_dim3_axis0_neg());
15215
15216 } // namespace generated_tests::softmax_v1_2
15217
15218 namespace generated_tests::softmax_v1_2 {
15219
get_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal()15220 const TestModel& get_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal() {
15221 static TestModel model = {
15222 .expectFailure = false,
15223 .expectedMultinomialDistributionTolerance = 0,
15224 .isRelaxed = false,
15225 .main = { // axis
15226 .inputIndexes = {4},
15227 .operands = {{ // op1
15228 .channelQuant = {},
15229 .data = TestBuffer::createFromVector<uint8_t>({}),
15230 .dimensions = {5, 2, 2},
15231 .isIgnored = false,
15232 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
15233 .numberOfConsumers = 1,
15234 .scale = 0.25f,
15235 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15236 .zeroPoint = 128
15237 }, { // param2
15238 .channelQuant = {},
15239 .data = TestBuffer::createFromVector<float>({1.0f}),
15240 .dimensions = {},
15241 .isIgnored = false,
15242 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15243 .numberOfConsumers = 1,
15244 .scale = 0.0f,
15245 .type = TestOperandType::FLOAT32,
15246 .zeroPoint = 0
15247 }, { // axis
15248 .channelQuant = {},
15249 .data = TestBuffer::createFromVector<int32_t>({-3}),
15250 .dimensions = {},
15251 .isIgnored = false,
15252 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15253 .numberOfConsumers = 1,
15254 .scale = 0.0f,
15255 .type = TestOperandType::INT32,
15256 .zeroPoint = 0
15257 }, { // op2
15258 .channelQuant = {},
15259 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 165, 165, 61, 61, 61, 61, 22, 22, 22, 22, 8, 8, 8, 8, 0, 0, 0, 0}),
15260 .dimensions = {5, 2, 2},
15261 .isIgnored = false,
15262 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15263 .numberOfConsumers = 0,
15264 .scale = 0.00390625f,
15265 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15266 .zeroPoint = 0
15267 }, { // op1_new
15268 .channelQuant = {},
15269 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 196, 124, 192, 120, 192, 120, 188, 116, 188, 116, 184, 112, 184, 112, 132, 60, 132, 60}),
15270 .dimensions = {5, 2, 2},
15271 .isIgnored = false,
15272 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15273 .numberOfConsumers = 1,
15274 .scale = 0.25f,
15275 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15276 .zeroPoint = 128
15277 }, { // placeholder93
15278 .channelQuant = {},
15279 .data = TestBuffer::createFromVector<uint8_t>({128}),
15280 .dimensions = {1},
15281 .isIgnored = false,
15282 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15283 .numberOfConsumers = 1,
15284 .scale = 0.25f,
15285 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15286 .zeroPoint = 128
15287 }, { // param111
15288 .channelQuant = {},
15289 .data = TestBuffer::createFromVector<int32_t>({0}),
15290 .dimensions = {},
15291 .isIgnored = false,
15292 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15293 .numberOfConsumers = 1,
15294 .scale = 0.0f,
15295 .type = TestOperandType::INT32,
15296 .zeroPoint = 0
15297 }},
15298 .operations = {{
15299 .inputs = {4, 5, 6},
15300 .outputs = {0},
15301 .type = TestOperationType::ADD
15302 }, {
15303 .inputs = {0, 1, 2},
15304 .outputs = {3},
15305 .type = TestOperationType::SOFTMAX
15306 }},
15307 .outputIndexes = {3}
15308 },
15309 .minSupportedVersion = TestHalVersion::V1_2,
15310 .referenced = {}
15311 };
15312 return model;
15313 }
15314
15315 const auto dummy_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal());
15316
15317 } // namespace generated_tests::softmax_v1_2
15318
15319 namespace generated_tests::softmax_v1_2 {
15320
get_test_model_axis_quant8_dim3_axis1()15321 const TestModel& get_test_model_axis_quant8_dim3_axis1() {
15322 static TestModel model = {
15323 .expectFailure = false,
15324 .expectedMultinomialDistributionTolerance = 0,
15325 .isRelaxed = false,
15326 .main = { // axis
15327 .inputIndexes = {0},
15328 .operands = {{ // op1
15329 .channelQuant = {},
15330 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
15331 .dimensions = {2, 5, 2},
15332 .isIgnored = false,
15333 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15334 .numberOfConsumers = 1,
15335 .scale = 0.25f,
15336 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15337 .zeroPoint = 128
15338 }, { // param2
15339 .channelQuant = {},
15340 .data = TestBuffer::createFromVector<float>({1.0f}),
15341 .dimensions = {},
15342 .isIgnored = false,
15343 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15344 .numberOfConsumers = 1,
15345 .scale = 0.0f,
15346 .type = TestOperandType::FLOAT32,
15347 .zeroPoint = 0
15348 }, { // axis
15349 .channelQuant = {},
15350 .data = TestBuffer::createFromVector<int32_t>({1}),
15351 .dimensions = {},
15352 .isIgnored = false,
15353 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15354 .numberOfConsumers = 1,
15355 .scale = 0.0f,
15356 .type = TestOperandType::INT32,
15357 .zeroPoint = 0
15358 }, { // op2
15359 .channelQuant = {},
15360 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
15361 .dimensions = {2, 5, 2},
15362 .isIgnored = false,
15363 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15364 .numberOfConsumers = 0,
15365 .scale = 0.00390625f,
15366 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15367 .zeroPoint = 0
15368 }},
15369 .operations = {{
15370 .inputs = {0, 1, 2},
15371 .outputs = {3},
15372 .type = TestOperationType::SOFTMAX
15373 }},
15374 .outputIndexes = {3}
15375 },
15376 .minSupportedVersion = TestHalVersion::V1_2,
15377 .referenced = {}
15378 };
15379 return model;
15380 }
15381
15382 const auto dummy_test_model_axis_quant8_dim3_axis1 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1", get_test_model_axis_quant8_dim3_axis1());
15383
15384 } // namespace generated_tests::softmax_v1_2
15385
15386 namespace generated_tests::softmax_v1_2 {
15387
get_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal()15388 const TestModel& get_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal() {
15389 static TestModel model = {
15390 .expectFailure = false,
15391 .expectedMultinomialDistributionTolerance = 0,
15392 .isRelaxed = false,
15393 .main = { // axis
15394 .inputIndexes = {4},
15395 .operands = {{ // op1
15396 .channelQuant = {},
15397 .data = TestBuffer::createFromVector<uint8_t>({}),
15398 .dimensions = {2, 5, 2},
15399 .isIgnored = false,
15400 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
15401 .numberOfConsumers = 1,
15402 .scale = 0.25f,
15403 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15404 .zeroPoint = 128
15405 }, { // param2
15406 .channelQuant = {},
15407 .data = TestBuffer::createFromVector<float>({1.0f}),
15408 .dimensions = {},
15409 .isIgnored = false,
15410 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15411 .numberOfConsumers = 1,
15412 .scale = 0.0f,
15413 .type = TestOperandType::FLOAT32,
15414 .zeroPoint = 0
15415 }, { // axis
15416 .channelQuant = {},
15417 .data = TestBuffer::createFromVector<int32_t>({1}),
15418 .dimensions = {},
15419 .isIgnored = false,
15420 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15421 .numberOfConsumers = 1,
15422 .scale = 0.0f,
15423 .type = TestOperandType::INT32,
15424 .zeroPoint = 0
15425 }, { // op2
15426 .channelQuant = {},
15427 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
15428 .dimensions = {2, 5, 2},
15429 .isIgnored = false,
15430 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15431 .numberOfConsumers = 0,
15432 .scale = 0.00390625f,
15433 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15434 .zeroPoint = 0
15435 }, { // op1_new
15436 .channelQuant = {},
15437 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
15438 .dimensions = {2, 5, 2},
15439 .isIgnored = false,
15440 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15441 .numberOfConsumers = 1,
15442 .scale = 0.25f,
15443 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15444 .zeroPoint = 128
15445 }, { // placeholder94
15446 .channelQuant = {},
15447 .data = TestBuffer::createFromVector<uint8_t>({128}),
15448 .dimensions = {1},
15449 .isIgnored = false,
15450 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15451 .numberOfConsumers = 1,
15452 .scale = 0.25f,
15453 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15454 .zeroPoint = 128
15455 }, { // param112
15456 .channelQuant = {},
15457 .data = TestBuffer::createFromVector<int32_t>({0}),
15458 .dimensions = {},
15459 .isIgnored = false,
15460 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15461 .numberOfConsumers = 1,
15462 .scale = 0.0f,
15463 .type = TestOperandType::INT32,
15464 .zeroPoint = 0
15465 }},
15466 .operations = {{
15467 .inputs = {4, 5, 6},
15468 .outputs = {0},
15469 .type = TestOperationType::ADD
15470 }, {
15471 .inputs = {0, 1, 2},
15472 .outputs = {3},
15473 .type = TestOperationType::SOFTMAX
15474 }},
15475 .outputIndexes = {3}
15476 },
15477 .minSupportedVersion = TestHalVersion::V1_2,
15478 .referenced = {}
15479 };
15480 return model;
15481 }
15482
15483 const auto dummy_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1_all_inputs_as_internal", get_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal());
15484
15485 } // namespace generated_tests::softmax_v1_2
15486
15487 namespace generated_tests::softmax_v1_2 {
15488
get_test_model_axis_quant8_dim3_axis1_neg()15489 const TestModel& get_test_model_axis_quant8_dim3_axis1_neg() {
15490 static TestModel model = {
15491 .expectFailure = false,
15492 .expectedMultinomialDistributionTolerance = 0,
15493 .isRelaxed = false,
15494 .main = { // axis
15495 .inputIndexes = {0},
15496 .operands = {{ // op1
15497 .channelQuant = {},
15498 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
15499 .dimensions = {2, 5, 2},
15500 .isIgnored = false,
15501 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15502 .numberOfConsumers = 1,
15503 .scale = 0.25f,
15504 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15505 .zeroPoint = 128
15506 }, { // param2
15507 .channelQuant = {},
15508 .data = TestBuffer::createFromVector<float>({1.0f}),
15509 .dimensions = {},
15510 .isIgnored = false,
15511 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15512 .numberOfConsumers = 1,
15513 .scale = 0.0f,
15514 .type = TestOperandType::FLOAT32,
15515 .zeroPoint = 0
15516 }, { // axis
15517 .channelQuant = {},
15518 .data = TestBuffer::createFromVector<int32_t>({-2}),
15519 .dimensions = {},
15520 .isIgnored = false,
15521 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15522 .numberOfConsumers = 1,
15523 .scale = 0.0f,
15524 .type = TestOperandType::INT32,
15525 .zeroPoint = 0
15526 }, { // op2
15527 .channelQuant = {},
15528 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
15529 .dimensions = {2, 5, 2},
15530 .isIgnored = false,
15531 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15532 .numberOfConsumers = 0,
15533 .scale = 0.00390625f,
15534 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15535 .zeroPoint = 0
15536 }},
15537 .operations = {{
15538 .inputs = {0, 1, 2},
15539 .outputs = {3},
15540 .type = TestOperationType::SOFTMAX
15541 }},
15542 .outputIndexes = {3}
15543 },
15544 .minSupportedVersion = TestHalVersion::V1_2,
15545 .referenced = {}
15546 };
15547 return model;
15548 }
15549
15550 const auto dummy_test_model_axis_quant8_dim3_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1_neg", get_test_model_axis_quant8_dim3_axis1_neg());
15551
15552 } // namespace generated_tests::softmax_v1_2
15553
15554 namespace generated_tests::softmax_v1_2 {
15555
get_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal()15556 const TestModel& get_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal() {
15557 static TestModel model = {
15558 .expectFailure = false,
15559 .expectedMultinomialDistributionTolerance = 0,
15560 .isRelaxed = false,
15561 .main = { // axis
15562 .inputIndexes = {4},
15563 .operands = {{ // op1
15564 .channelQuant = {},
15565 .data = TestBuffer::createFromVector<uint8_t>({}),
15566 .dimensions = {2, 5, 2},
15567 .isIgnored = false,
15568 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
15569 .numberOfConsumers = 1,
15570 .scale = 0.25f,
15571 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15572 .zeroPoint = 128
15573 }, { // param2
15574 .channelQuant = {},
15575 .data = TestBuffer::createFromVector<float>({1.0f}),
15576 .dimensions = {},
15577 .isIgnored = false,
15578 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15579 .numberOfConsumers = 1,
15580 .scale = 0.0f,
15581 .type = TestOperandType::FLOAT32,
15582 .zeroPoint = 0
15583 }, { // axis
15584 .channelQuant = {},
15585 .data = TestBuffer::createFromVector<int32_t>({-2}),
15586 .dimensions = {},
15587 .isIgnored = false,
15588 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15589 .numberOfConsumers = 1,
15590 .scale = 0.0f,
15591 .type = TestOperandType::INT32,
15592 .zeroPoint = 0
15593 }, { // op2
15594 .channelQuant = {},
15595 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0, 165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
15596 .dimensions = {2, 5, 2},
15597 .isIgnored = false,
15598 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15599 .numberOfConsumers = 0,
15600 .scale = 0.00390625f,
15601 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15602 .zeroPoint = 0
15603 }, { // op1_new
15604 .channelQuant = {},
15605 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60, 196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
15606 .dimensions = {2, 5, 2},
15607 .isIgnored = false,
15608 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15609 .numberOfConsumers = 1,
15610 .scale = 0.25f,
15611 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15612 .zeroPoint = 128
15613 }, { // placeholder95
15614 .channelQuant = {},
15615 .data = TestBuffer::createFromVector<uint8_t>({128}),
15616 .dimensions = {1},
15617 .isIgnored = false,
15618 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15619 .numberOfConsumers = 1,
15620 .scale = 0.25f,
15621 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15622 .zeroPoint = 128
15623 }, { // param113
15624 .channelQuant = {},
15625 .data = TestBuffer::createFromVector<int32_t>({0}),
15626 .dimensions = {},
15627 .isIgnored = false,
15628 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15629 .numberOfConsumers = 1,
15630 .scale = 0.0f,
15631 .type = TestOperandType::INT32,
15632 .zeroPoint = 0
15633 }},
15634 .operations = {{
15635 .inputs = {4, 5, 6},
15636 .outputs = {0},
15637 .type = TestOperationType::ADD
15638 }, {
15639 .inputs = {0, 1, 2},
15640 .outputs = {3},
15641 .type = TestOperationType::SOFTMAX
15642 }},
15643 .outputIndexes = {3}
15644 },
15645 .minSupportedVersion = TestHalVersion::V1_2,
15646 .referenced = {}
15647 };
15648 return model;
15649 }
15650
15651 const auto dummy_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal());
15652
15653 } // namespace generated_tests::softmax_v1_2
15654
15655 namespace generated_tests::softmax_v1_2 {
15656
get_test_model_axis_quant8_dim3_axis2()15657 const TestModel& get_test_model_axis_quant8_dim3_axis2() {
15658 static TestModel model = {
15659 .expectFailure = false,
15660 .expectedMultinomialDistributionTolerance = 0,
15661 .isRelaxed = false,
15662 .main = { // axis
15663 .inputIndexes = {0},
15664 .operands = {{ // op1
15665 .channelQuant = {},
15666 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
15667 .dimensions = {2, 2, 5},
15668 .isIgnored = false,
15669 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15670 .numberOfConsumers = 1,
15671 .scale = 0.25f,
15672 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15673 .zeroPoint = 128
15674 }, { // param2
15675 .channelQuant = {},
15676 .data = TestBuffer::createFromVector<float>({1.0f}),
15677 .dimensions = {},
15678 .isIgnored = false,
15679 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15680 .numberOfConsumers = 1,
15681 .scale = 0.0f,
15682 .type = TestOperandType::FLOAT32,
15683 .zeroPoint = 0
15684 }, { // axis
15685 .channelQuant = {},
15686 .data = TestBuffer::createFromVector<int32_t>({2}),
15687 .dimensions = {},
15688 .isIgnored = false,
15689 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15690 .numberOfConsumers = 1,
15691 .scale = 0.0f,
15692 .type = TestOperandType::INT32,
15693 .zeroPoint = 0
15694 }, { // op2
15695 .channelQuant = {},
15696 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
15697 .dimensions = {2, 2, 5},
15698 .isIgnored = false,
15699 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15700 .numberOfConsumers = 0,
15701 .scale = 0.00390625f,
15702 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15703 .zeroPoint = 0
15704 }},
15705 .operations = {{
15706 .inputs = {0, 1, 2},
15707 .outputs = {3},
15708 .type = TestOperationType::SOFTMAX
15709 }},
15710 .outputIndexes = {3}
15711 },
15712 .minSupportedVersion = TestHalVersion::V1_2,
15713 .referenced = {}
15714 };
15715 return model;
15716 }
15717
15718 const auto dummy_test_model_axis_quant8_dim3_axis2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2", get_test_model_axis_quant8_dim3_axis2());
15719
15720 } // namespace generated_tests::softmax_v1_2
15721
15722 namespace generated_tests::softmax_v1_2 {
15723
get_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal()15724 const TestModel& get_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal() {
15725 static TestModel model = {
15726 .expectFailure = false,
15727 .expectedMultinomialDistributionTolerance = 0,
15728 .isRelaxed = false,
15729 .main = { // axis
15730 .inputIndexes = {4},
15731 .operands = {{ // op1
15732 .channelQuant = {},
15733 .data = TestBuffer::createFromVector<uint8_t>({}),
15734 .dimensions = {2, 2, 5},
15735 .isIgnored = false,
15736 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
15737 .numberOfConsumers = 1,
15738 .scale = 0.25f,
15739 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15740 .zeroPoint = 128
15741 }, { // param2
15742 .channelQuant = {},
15743 .data = TestBuffer::createFromVector<float>({1.0f}),
15744 .dimensions = {},
15745 .isIgnored = false,
15746 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15747 .numberOfConsumers = 1,
15748 .scale = 0.0f,
15749 .type = TestOperandType::FLOAT32,
15750 .zeroPoint = 0
15751 }, { // axis
15752 .channelQuant = {},
15753 .data = TestBuffer::createFromVector<int32_t>({2}),
15754 .dimensions = {},
15755 .isIgnored = false,
15756 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15757 .numberOfConsumers = 1,
15758 .scale = 0.0f,
15759 .type = TestOperandType::INT32,
15760 .zeroPoint = 0
15761 }, { // op2
15762 .channelQuant = {},
15763 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
15764 .dimensions = {2, 2, 5},
15765 .isIgnored = false,
15766 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15767 .numberOfConsumers = 0,
15768 .scale = 0.00390625f,
15769 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15770 .zeroPoint = 0
15771 }, { // op1_new
15772 .channelQuant = {},
15773 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
15774 .dimensions = {2, 2, 5},
15775 .isIgnored = false,
15776 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15777 .numberOfConsumers = 1,
15778 .scale = 0.25f,
15779 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15780 .zeroPoint = 128
15781 }, { // placeholder96
15782 .channelQuant = {},
15783 .data = TestBuffer::createFromVector<uint8_t>({128}),
15784 .dimensions = {1},
15785 .isIgnored = false,
15786 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15787 .numberOfConsumers = 1,
15788 .scale = 0.25f,
15789 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15790 .zeroPoint = 128
15791 }, { // param114
15792 .channelQuant = {},
15793 .data = TestBuffer::createFromVector<int32_t>({0}),
15794 .dimensions = {},
15795 .isIgnored = false,
15796 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15797 .numberOfConsumers = 1,
15798 .scale = 0.0f,
15799 .type = TestOperandType::INT32,
15800 .zeroPoint = 0
15801 }},
15802 .operations = {{
15803 .inputs = {4, 5, 6},
15804 .outputs = {0},
15805 .type = TestOperationType::ADD
15806 }, {
15807 .inputs = {0, 1, 2},
15808 .outputs = {3},
15809 .type = TestOperationType::SOFTMAX
15810 }},
15811 .outputIndexes = {3}
15812 },
15813 .minSupportedVersion = TestHalVersion::V1_2,
15814 .referenced = {}
15815 };
15816 return model;
15817 }
15818
15819 const auto dummy_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2_all_inputs_as_internal", get_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal());
15820
15821 } // namespace generated_tests::softmax_v1_2
15822
15823 namespace generated_tests::softmax_v1_2 {
15824
get_test_model_axis_quant8_dim3_axis2_neg()15825 const TestModel& get_test_model_axis_quant8_dim3_axis2_neg() {
15826 static TestModel model = {
15827 .expectFailure = false,
15828 .expectedMultinomialDistributionTolerance = 0,
15829 .isRelaxed = false,
15830 .main = { // axis
15831 .inputIndexes = {0},
15832 .operands = {{ // op1
15833 .channelQuant = {},
15834 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
15835 .dimensions = {2, 2, 5},
15836 .isIgnored = false,
15837 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15838 .numberOfConsumers = 1,
15839 .scale = 0.25f,
15840 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15841 .zeroPoint = 128
15842 }, { // param2
15843 .channelQuant = {},
15844 .data = TestBuffer::createFromVector<float>({1.0f}),
15845 .dimensions = {},
15846 .isIgnored = false,
15847 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15848 .numberOfConsumers = 1,
15849 .scale = 0.0f,
15850 .type = TestOperandType::FLOAT32,
15851 .zeroPoint = 0
15852 }, { // axis
15853 .channelQuant = {},
15854 .data = TestBuffer::createFromVector<int32_t>({-1}),
15855 .dimensions = {},
15856 .isIgnored = false,
15857 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15858 .numberOfConsumers = 1,
15859 .scale = 0.0f,
15860 .type = TestOperandType::INT32,
15861 .zeroPoint = 0
15862 }, { // op2
15863 .channelQuant = {},
15864 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
15865 .dimensions = {2, 2, 5},
15866 .isIgnored = false,
15867 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15868 .numberOfConsumers = 0,
15869 .scale = 0.00390625f,
15870 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15871 .zeroPoint = 0
15872 }},
15873 .operations = {{
15874 .inputs = {0, 1, 2},
15875 .outputs = {3},
15876 .type = TestOperationType::SOFTMAX
15877 }},
15878 .outputIndexes = {3}
15879 },
15880 .minSupportedVersion = TestHalVersion::V1_2,
15881 .referenced = {}
15882 };
15883 return model;
15884 }
15885
15886 const auto dummy_test_model_axis_quant8_dim3_axis2_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2_neg", get_test_model_axis_quant8_dim3_axis2_neg());
15887
15888 } // namespace generated_tests::softmax_v1_2
15889
15890 namespace generated_tests::softmax_v1_2 {
15891
get_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal()15892 const TestModel& get_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal() {
15893 static TestModel model = {
15894 .expectFailure = false,
15895 .expectedMultinomialDistributionTolerance = 0,
15896 .isRelaxed = false,
15897 .main = { // axis
15898 .inputIndexes = {4},
15899 .operands = {{ // op1
15900 .channelQuant = {},
15901 .data = TestBuffer::createFromVector<uint8_t>({}),
15902 .dimensions = {2, 2, 5},
15903 .isIgnored = false,
15904 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
15905 .numberOfConsumers = 1,
15906 .scale = 0.25f,
15907 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15908 .zeroPoint = 128
15909 }, { // param2
15910 .channelQuant = {},
15911 .data = TestBuffer::createFromVector<float>({1.0f}),
15912 .dimensions = {},
15913 .isIgnored = false,
15914 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15915 .numberOfConsumers = 1,
15916 .scale = 0.0f,
15917 .type = TestOperandType::FLOAT32,
15918 .zeroPoint = 0
15919 }, { // axis
15920 .channelQuant = {},
15921 .data = TestBuffer::createFromVector<int32_t>({-1}),
15922 .dimensions = {},
15923 .isIgnored = false,
15924 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15925 .numberOfConsumers = 1,
15926 .scale = 0.0f,
15927 .type = TestOperandType::INT32,
15928 .zeroPoint = 0
15929 }, { // op2
15930 .channelQuant = {},
15931 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
15932 .dimensions = {2, 2, 5},
15933 .isIgnored = false,
15934 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
15935 .numberOfConsumers = 0,
15936 .scale = 0.00390625f,
15937 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15938 .zeroPoint = 0
15939 }, { // op1_new
15940 .channelQuant = {},
15941 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60, 196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
15942 .dimensions = {2, 2, 5},
15943 .isIgnored = false,
15944 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
15945 .numberOfConsumers = 1,
15946 .scale = 0.25f,
15947 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15948 .zeroPoint = 128
15949 }, { // placeholder97
15950 .channelQuant = {},
15951 .data = TestBuffer::createFromVector<uint8_t>({128}),
15952 .dimensions = {1},
15953 .isIgnored = false,
15954 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15955 .numberOfConsumers = 1,
15956 .scale = 0.25f,
15957 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
15958 .zeroPoint = 128
15959 }, { // param115
15960 .channelQuant = {},
15961 .data = TestBuffer::createFromVector<int32_t>({0}),
15962 .dimensions = {},
15963 .isIgnored = false,
15964 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
15965 .numberOfConsumers = 1,
15966 .scale = 0.0f,
15967 .type = TestOperandType::INT32,
15968 .zeroPoint = 0
15969 }},
15970 .operations = {{
15971 .inputs = {4, 5, 6},
15972 .outputs = {0},
15973 .type = TestOperationType::ADD
15974 }, {
15975 .inputs = {0, 1, 2},
15976 .outputs = {3},
15977 .type = TestOperationType::SOFTMAX
15978 }},
15979 .outputIndexes = {3}
15980 },
15981 .minSupportedVersion = TestHalVersion::V1_2,
15982 .referenced = {}
15983 };
15984 return model;
15985 }
15986
15987 const auto dummy_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal());
15988
15989 } // namespace generated_tests::softmax_v1_2
15990
15991 namespace generated_tests::softmax_v1_2 {
15992
get_test_model_axis_quant8_dim2_axis0()15993 const TestModel& get_test_model_axis_quant8_dim2_axis0() {
15994 static TestModel model = {
15995 .expectFailure = false,
15996 .expectedMultinomialDistributionTolerance = 0,
15997 .isRelaxed = false,
15998 .main = { // axis
15999 .inputIndexes = {0},
16000 .operands = {{ // op1
16001 .channelQuant = {},
16002 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
16003 .dimensions = {5, 2},
16004 .isIgnored = false,
16005 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16006 .numberOfConsumers = 1,
16007 .scale = 0.25f,
16008 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16009 .zeroPoint = 128
16010 }, { // param2
16011 .channelQuant = {},
16012 .data = TestBuffer::createFromVector<float>({1.0f}),
16013 .dimensions = {},
16014 .isIgnored = false,
16015 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16016 .numberOfConsumers = 1,
16017 .scale = 0.0f,
16018 .type = TestOperandType::FLOAT32,
16019 .zeroPoint = 0
16020 }, { // axis
16021 .channelQuant = {},
16022 .data = TestBuffer::createFromVector<int32_t>({0}),
16023 .dimensions = {},
16024 .isIgnored = false,
16025 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16026 .numberOfConsumers = 1,
16027 .scale = 0.0f,
16028 .type = TestOperandType::INT32,
16029 .zeroPoint = 0
16030 }, { // op2
16031 .channelQuant = {},
16032 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
16033 .dimensions = {5, 2},
16034 .isIgnored = false,
16035 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16036 .numberOfConsumers = 0,
16037 .scale = 0.00390625f,
16038 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16039 .zeroPoint = 0
16040 }},
16041 .operations = {{
16042 .inputs = {0, 1, 2},
16043 .outputs = {3},
16044 .type = TestOperationType::SOFTMAX
16045 }},
16046 .outputIndexes = {3}
16047 },
16048 .minSupportedVersion = TestHalVersion::V1_2,
16049 .referenced = {}
16050 };
16051 return model;
16052 }
16053
16054 const auto dummy_test_model_axis_quant8_dim2_axis0 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0", get_test_model_axis_quant8_dim2_axis0());
16055
16056 } // namespace generated_tests::softmax_v1_2
16057
16058 namespace generated_tests::softmax_v1_2 {
16059
get_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal()16060 const TestModel& get_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal() {
16061 static TestModel model = {
16062 .expectFailure = false,
16063 .expectedMultinomialDistributionTolerance = 0,
16064 .isRelaxed = false,
16065 .main = { // axis
16066 .inputIndexes = {4},
16067 .operands = {{ // op1
16068 .channelQuant = {},
16069 .data = TestBuffer::createFromVector<uint8_t>({}),
16070 .dimensions = {5, 2},
16071 .isIgnored = false,
16072 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
16073 .numberOfConsumers = 1,
16074 .scale = 0.25f,
16075 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16076 .zeroPoint = 128
16077 }, { // param2
16078 .channelQuant = {},
16079 .data = TestBuffer::createFromVector<float>({1.0f}),
16080 .dimensions = {},
16081 .isIgnored = false,
16082 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16083 .numberOfConsumers = 1,
16084 .scale = 0.0f,
16085 .type = TestOperandType::FLOAT32,
16086 .zeroPoint = 0
16087 }, { // axis
16088 .channelQuant = {},
16089 .data = TestBuffer::createFromVector<int32_t>({0}),
16090 .dimensions = {},
16091 .isIgnored = false,
16092 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16093 .numberOfConsumers = 1,
16094 .scale = 0.0f,
16095 .type = TestOperandType::INT32,
16096 .zeroPoint = 0
16097 }, { // op2
16098 .channelQuant = {},
16099 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
16100 .dimensions = {5, 2},
16101 .isIgnored = false,
16102 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16103 .numberOfConsumers = 0,
16104 .scale = 0.00390625f,
16105 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16106 .zeroPoint = 0
16107 }, { // op1_new
16108 .channelQuant = {},
16109 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
16110 .dimensions = {5, 2},
16111 .isIgnored = false,
16112 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16113 .numberOfConsumers = 1,
16114 .scale = 0.25f,
16115 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16116 .zeroPoint = 128
16117 }, { // placeholder98
16118 .channelQuant = {},
16119 .data = TestBuffer::createFromVector<uint8_t>({128}),
16120 .dimensions = {1},
16121 .isIgnored = false,
16122 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16123 .numberOfConsumers = 1,
16124 .scale = 0.25f,
16125 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16126 .zeroPoint = 128
16127 }, { // param116
16128 .channelQuant = {},
16129 .data = TestBuffer::createFromVector<int32_t>({0}),
16130 .dimensions = {},
16131 .isIgnored = false,
16132 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16133 .numberOfConsumers = 1,
16134 .scale = 0.0f,
16135 .type = TestOperandType::INT32,
16136 .zeroPoint = 0
16137 }},
16138 .operations = {{
16139 .inputs = {4, 5, 6},
16140 .outputs = {0},
16141 .type = TestOperationType::ADD
16142 }, {
16143 .inputs = {0, 1, 2},
16144 .outputs = {3},
16145 .type = TestOperationType::SOFTMAX
16146 }},
16147 .outputIndexes = {3}
16148 },
16149 .minSupportedVersion = TestHalVersion::V1_2,
16150 .referenced = {}
16151 };
16152 return model;
16153 }
16154
16155 const auto dummy_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0_all_inputs_as_internal", get_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal());
16156
16157 } // namespace generated_tests::softmax_v1_2
16158
16159 namespace generated_tests::softmax_v1_2 {
16160
get_test_model_axis_quant8_dim2_axis0_neg()16161 const TestModel& get_test_model_axis_quant8_dim2_axis0_neg() {
16162 static TestModel model = {
16163 .expectFailure = false,
16164 .expectedMultinomialDistributionTolerance = 0,
16165 .isRelaxed = false,
16166 .main = { // axis
16167 .inputIndexes = {0},
16168 .operands = {{ // op1
16169 .channelQuant = {},
16170 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
16171 .dimensions = {5, 2},
16172 .isIgnored = false,
16173 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16174 .numberOfConsumers = 1,
16175 .scale = 0.25f,
16176 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16177 .zeroPoint = 128
16178 }, { // param2
16179 .channelQuant = {},
16180 .data = TestBuffer::createFromVector<float>({1.0f}),
16181 .dimensions = {},
16182 .isIgnored = false,
16183 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16184 .numberOfConsumers = 1,
16185 .scale = 0.0f,
16186 .type = TestOperandType::FLOAT32,
16187 .zeroPoint = 0
16188 }, { // axis
16189 .channelQuant = {},
16190 .data = TestBuffer::createFromVector<int32_t>({-2}),
16191 .dimensions = {},
16192 .isIgnored = false,
16193 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16194 .numberOfConsumers = 1,
16195 .scale = 0.0f,
16196 .type = TestOperandType::INT32,
16197 .zeroPoint = 0
16198 }, { // op2
16199 .channelQuant = {},
16200 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
16201 .dimensions = {5, 2},
16202 .isIgnored = false,
16203 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16204 .numberOfConsumers = 0,
16205 .scale = 0.00390625f,
16206 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16207 .zeroPoint = 0
16208 }},
16209 .operations = {{
16210 .inputs = {0, 1, 2},
16211 .outputs = {3},
16212 .type = TestOperationType::SOFTMAX
16213 }},
16214 .outputIndexes = {3}
16215 },
16216 .minSupportedVersion = TestHalVersion::V1_2,
16217 .referenced = {}
16218 };
16219 return model;
16220 }
16221
16222 const auto dummy_test_model_axis_quant8_dim2_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0_neg", get_test_model_axis_quant8_dim2_axis0_neg());
16223
16224 } // namespace generated_tests::softmax_v1_2
16225
16226 namespace generated_tests::softmax_v1_2 {
16227
get_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal()16228 const TestModel& get_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal() {
16229 static TestModel model = {
16230 .expectFailure = false,
16231 .expectedMultinomialDistributionTolerance = 0,
16232 .isRelaxed = false,
16233 .main = { // axis
16234 .inputIndexes = {4},
16235 .operands = {{ // op1
16236 .channelQuant = {},
16237 .data = TestBuffer::createFromVector<uint8_t>({}),
16238 .dimensions = {5, 2},
16239 .isIgnored = false,
16240 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
16241 .numberOfConsumers = 1,
16242 .scale = 0.25f,
16243 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16244 .zeroPoint = 128
16245 }, { // param2
16246 .channelQuant = {},
16247 .data = TestBuffer::createFromVector<float>({1.0f}),
16248 .dimensions = {},
16249 .isIgnored = false,
16250 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16251 .numberOfConsumers = 1,
16252 .scale = 0.0f,
16253 .type = TestOperandType::FLOAT32,
16254 .zeroPoint = 0
16255 }, { // axis
16256 .channelQuant = {},
16257 .data = TestBuffer::createFromVector<int32_t>({-2}),
16258 .dimensions = {},
16259 .isIgnored = false,
16260 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16261 .numberOfConsumers = 1,
16262 .scale = 0.0f,
16263 .type = TestOperandType::INT32,
16264 .zeroPoint = 0
16265 }, { // op2
16266 .channelQuant = {},
16267 .data = TestBuffer::createFromVector<uint8_t>({165, 165, 61, 61, 22, 22, 8, 8, 0, 0}),
16268 .dimensions = {5, 2},
16269 .isIgnored = false,
16270 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16271 .numberOfConsumers = 0,
16272 .scale = 0.00390625f,
16273 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16274 .zeroPoint = 0
16275 }, { // op1_new
16276 .channelQuant = {},
16277 .data = TestBuffer::createFromVector<uint8_t>({196, 124, 192, 120, 188, 116, 184, 112, 132, 60}),
16278 .dimensions = {5, 2},
16279 .isIgnored = false,
16280 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16281 .numberOfConsumers = 1,
16282 .scale = 0.25f,
16283 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16284 .zeroPoint = 128
16285 }, { // placeholder99
16286 .channelQuant = {},
16287 .data = TestBuffer::createFromVector<uint8_t>({128}),
16288 .dimensions = {1},
16289 .isIgnored = false,
16290 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16291 .numberOfConsumers = 1,
16292 .scale = 0.25f,
16293 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16294 .zeroPoint = 128
16295 }, { // param117
16296 .channelQuant = {},
16297 .data = TestBuffer::createFromVector<int32_t>({0}),
16298 .dimensions = {},
16299 .isIgnored = false,
16300 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16301 .numberOfConsumers = 1,
16302 .scale = 0.0f,
16303 .type = TestOperandType::INT32,
16304 .zeroPoint = 0
16305 }},
16306 .operations = {{
16307 .inputs = {4, 5, 6},
16308 .outputs = {0},
16309 .type = TestOperationType::ADD
16310 }, {
16311 .inputs = {0, 1, 2},
16312 .outputs = {3},
16313 .type = TestOperationType::SOFTMAX
16314 }},
16315 .outputIndexes = {3}
16316 },
16317 .minSupportedVersion = TestHalVersion::V1_2,
16318 .referenced = {}
16319 };
16320 return model;
16321 }
16322
16323 const auto dummy_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal());
16324
16325 } // namespace generated_tests::softmax_v1_2
16326
16327 namespace generated_tests::softmax_v1_2 {
16328
get_test_model_axis_quant8_dim2_axis1()16329 const TestModel& get_test_model_axis_quant8_dim2_axis1() {
16330 static TestModel model = {
16331 .expectFailure = false,
16332 .expectedMultinomialDistributionTolerance = 0,
16333 .isRelaxed = false,
16334 .main = { // axis
16335 .inputIndexes = {0},
16336 .operands = {{ // op1
16337 .channelQuant = {},
16338 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
16339 .dimensions = {2, 5},
16340 .isIgnored = false,
16341 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16342 .numberOfConsumers = 1,
16343 .scale = 0.25f,
16344 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16345 .zeroPoint = 128
16346 }, { // param2
16347 .channelQuant = {},
16348 .data = TestBuffer::createFromVector<float>({1.0f}),
16349 .dimensions = {},
16350 .isIgnored = false,
16351 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16352 .numberOfConsumers = 1,
16353 .scale = 0.0f,
16354 .type = TestOperandType::FLOAT32,
16355 .zeroPoint = 0
16356 }, { // axis
16357 .channelQuant = {},
16358 .data = TestBuffer::createFromVector<int32_t>({1}),
16359 .dimensions = {},
16360 .isIgnored = false,
16361 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16362 .numberOfConsumers = 1,
16363 .scale = 0.0f,
16364 .type = TestOperandType::INT32,
16365 .zeroPoint = 0
16366 }, { // op2
16367 .channelQuant = {},
16368 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
16369 .dimensions = {2, 5},
16370 .isIgnored = false,
16371 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16372 .numberOfConsumers = 0,
16373 .scale = 0.00390625f,
16374 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16375 .zeroPoint = 0
16376 }},
16377 .operations = {{
16378 .inputs = {0, 1, 2},
16379 .outputs = {3},
16380 .type = TestOperationType::SOFTMAX
16381 }},
16382 .outputIndexes = {3}
16383 },
16384 .minSupportedVersion = TestHalVersion::V1_2,
16385 .referenced = {}
16386 };
16387 return model;
16388 }
16389
16390 const auto dummy_test_model_axis_quant8_dim2_axis1 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1", get_test_model_axis_quant8_dim2_axis1());
16391
16392 } // namespace generated_tests::softmax_v1_2
16393
16394 namespace generated_tests::softmax_v1_2 {
16395
get_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal()16396 const TestModel& get_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal() {
16397 static TestModel model = {
16398 .expectFailure = false,
16399 .expectedMultinomialDistributionTolerance = 0,
16400 .isRelaxed = false,
16401 .main = { // axis
16402 .inputIndexes = {4},
16403 .operands = {{ // op1
16404 .channelQuant = {},
16405 .data = TestBuffer::createFromVector<uint8_t>({}),
16406 .dimensions = {2, 5},
16407 .isIgnored = false,
16408 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
16409 .numberOfConsumers = 1,
16410 .scale = 0.25f,
16411 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16412 .zeroPoint = 128
16413 }, { // param2
16414 .channelQuant = {},
16415 .data = TestBuffer::createFromVector<float>({1.0f}),
16416 .dimensions = {},
16417 .isIgnored = false,
16418 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16419 .numberOfConsumers = 1,
16420 .scale = 0.0f,
16421 .type = TestOperandType::FLOAT32,
16422 .zeroPoint = 0
16423 }, { // axis
16424 .channelQuant = {},
16425 .data = TestBuffer::createFromVector<int32_t>({1}),
16426 .dimensions = {},
16427 .isIgnored = false,
16428 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16429 .numberOfConsumers = 1,
16430 .scale = 0.0f,
16431 .type = TestOperandType::INT32,
16432 .zeroPoint = 0
16433 }, { // op2
16434 .channelQuant = {},
16435 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
16436 .dimensions = {2, 5},
16437 .isIgnored = false,
16438 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16439 .numberOfConsumers = 0,
16440 .scale = 0.00390625f,
16441 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16442 .zeroPoint = 0
16443 }, { // op1_new
16444 .channelQuant = {},
16445 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
16446 .dimensions = {2, 5},
16447 .isIgnored = false,
16448 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16449 .numberOfConsumers = 1,
16450 .scale = 0.25f,
16451 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16452 .zeroPoint = 128
16453 }, { // placeholder100
16454 .channelQuant = {},
16455 .data = TestBuffer::createFromVector<uint8_t>({128}),
16456 .dimensions = {1},
16457 .isIgnored = false,
16458 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16459 .numberOfConsumers = 1,
16460 .scale = 0.25f,
16461 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16462 .zeroPoint = 128
16463 }, { // param118
16464 .channelQuant = {},
16465 .data = TestBuffer::createFromVector<int32_t>({0}),
16466 .dimensions = {},
16467 .isIgnored = false,
16468 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16469 .numberOfConsumers = 1,
16470 .scale = 0.0f,
16471 .type = TestOperandType::INT32,
16472 .zeroPoint = 0
16473 }},
16474 .operations = {{
16475 .inputs = {4, 5, 6},
16476 .outputs = {0},
16477 .type = TestOperationType::ADD
16478 }, {
16479 .inputs = {0, 1, 2},
16480 .outputs = {3},
16481 .type = TestOperationType::SOFTMAX
16482 }},
16483 .outputIndexes = {3}
16484 },
16485 .minSupportedVersion = TestHalVersion::V1_2,
16486 .referenced = {}
16487 };
16488 return model;
16489 }
16490
16491 const auto dummy_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1_all_inputs_as_internal", get_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal());
16492
16493 } // namespace generated_tests::softmax_v1_2
16494
16495 namespace generated_tests::softmax_v1_2 {
16496
get_test_model_axis_quant8_dim2_axis1_neg()16497 const TestModel& get_test_model_axis_quant8_dim2_axis1_neg() {
16498 static TestModel model = {
16499 .expectFailure = false,
16500 .expectedMultinomialDistributionTolerance = 0,
16501 .isRelaxed = false,
16502 .main = { // axis
16503 .inputIndexes = {0},
16504 .operands = {{ // op1
16505 .channelQuant = {},
16506 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
16507 .dimensions = {2, 5},
16508 .isIgnored = false,
16509 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16510 .numberOfConsumers = 1,
16511 .scale = 0.25f,
16512 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16513 .zeroPoint = 128
16514 }, { // param2
16515 .channelQuant = {},
16516 .data = TestBuffer::createFromVector<float>({1.0f}),
16517 .dimensions = {},
16518 .isIgnored = false,
16519 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16520 .numberOfConsumers = 1,
16521 .scale = 0.0f,
16522 .type = TestOperandType::FLOAT32,
16523 .zeroPoint = 0
16524 }, { // axis
16525 .channelQuant = {},
16526 .data = TestBuffer::createFromVector<int32_t>({-1}),
16527 .dimensions = {},
16528 .isIgnored = false,
16529 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16530 .numberOfConsumers = 1,
16531 .scale = 0.0f,
16532 .type = TestOperandType::INT32,
16533 .zeroPoint = 0
16534 }, { // op2
16535 .channelQuant = {},
16536 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
16537 .dimensions = {2, 5},
16538 .isIgnored = false,
16539 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16540 .numberOfConsumers = 0,
16541 .scale = 0.00390625f,
16542 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16543 .zeroPoint = 0
16544 }},
16545 .operations = {{
16546 .inputs = {0, 1, 2},
16547 .outputs = {3},
16548 .type = TestOperationType::SOFTMAX
16549 }},
16550 .outputIndexes = {3}
16551 },
16552 .minSupportedVersion = TestHalVersion::V1_0,
16553 .referenced = {}
16554 };
16555 return model;
16556 }
16557
16558 const auto dummy_test_model_axis_quant8_dim2_axis1_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1_neg", get_test_model_axis_quant8_dim2_axis1_neg());
16559
16560 } // namespace generated_tests::softmax_v1_2
16561
16562 namespace generated_tests::softmax_v1_2 {
16563
get_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal()16564 const TestModel& get_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal() {
16565 static TestModel model = {
16566 .expectFailure = false,
16567 .expectedMultinomialDistributionTolerance = 0,
16568 .isRelaxed = false,
16569 .main = { // axis
16570 .inputIndexes = {4},
16571 .operands = {{ // op1
16572 .channelQuant = {},
16573 .data = TestBuffer::createFromVector<uint8_t>({}),
16574 .dimensions = {2, 5},
16575 .isIgnored = false,
16576 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
16577 .numberOfConsumers = 1,
16578 .scale = 0.25f,
16579 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16580 .zeroPoint = 128
16581 }, { // param2
16582 .channelQuant = {},
16583 .data = TestBuffer::createFromVector<float>({1.0f}),
16584 .dimensions = {},
16585 .isIgnored = false,
16586 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16587 .numberOfConsumers = 1,
16588 .scale = 0.0f,
16589 .type = TestOperandType::FLOAT32,
16590 .zeroPoint = 0
16591 }, { // axis
16592 .channelQuant = {},
16593 .data = TestBuffer::createFromVector<int32_t>({-1}),
16594 .dimensions = {},
16595 .isIgnored = false,
16596 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16597 .numberOfConsumers = 1,
16598 .scale = 0.0f,
16599 .type = TestOperandType::INT32,
16600 .zeroPoint = 0
16601 }, { // op2
16602 .channelQuant = {},
16603 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0, 165, 61, 22, 8, 0}),
16604 .dimensions = {2, 5},
16605 .isIgnored = false,
16606 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16607 .numberOfConsumers = 0,
16608 .scale = 0.00390625f,
16609 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16610 .zeroPoint = 0
16611 }, { // op1_new
16612 .channelQuant = {},
16613 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132, 124, 120, 116, 112, 60}),
16614 .dimensions = {2, 5},
16615 .isIgnored = false,
16616 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16617 .numberOfConsumers = 1,
16618 .scale = 0.25f,
16619 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16620 .zeroPoint = 128
16621 }, { // placeholder101
16622 .channelQuant = {},
16623 .data = TestBuffer::createFromVector<uint8_t>({128}),
16624 .dimensions = {1},
16625 .isIgnored = false,
16626 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16627 .numberOfConsumers = 1,
16628 .scale = 0.25f,
16629 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16630 .zeroPoint = 128
16631 }, { // param119
16632 .channelQuant = {},
16633 .data = TestBuffer::createFromVector<int32_t>({0}),
16634 .dimensions = {},
16635 .isIgnored = false,
16636 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16637 .numberOfConsumers = 1,
16638 .scale = 0.0f,
16639 .type = TestOperandType::INT32,
16640 .zeroPoint = 0
16641 }},
16642 .operations = {{
16643 .inputs = {4, 5, 6},
16644 .outputs = {0},
16645 .type = TestOperationType::ADD
16646 }, {
16647 .inputs = {0, 1, 2},
16648 .outputs = {3},
16649 .type = TestOperationType::SOFTMAX
16650 }},
16651 .outputIndexes = {3}
16652 },
16653 .minSupportedVersion = TestHalVersion::V1_0,
16654 .referenced = {}
16655 };
16656 return model;
16657 }
16658
16659 const auto dummy_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal());
16660
16661 } // namespace generated_tests::softmax_v1_2
16662
16663 namespace generated_tests::softmax_v1_2 {
16664
get_test_model_axis_quant8_dim1_axis0()16665 const TestModel& get_test_model_axis_quant8_dim1_axis0() {
16666 static TestModel model = {
16667 .expectFailure = false,
16668 .expectedMultinomialDistributionTolerance = 0,
16669 .isRelaxed = false,
16670 .main = { // axis
16671 .inputIndexes = {0},
16672 .operands = {{ // op1
16673 .channelQuant = {},
16674 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132}),
16675 .dimensions = {5},
16676 .isIgnored = false,
16677 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16678 .numberOfConsumers = 1,
16679 .scale = 0.25f,
16680 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16681 .zeroPoint = 128
16682 }, { // param2
16683 .channelQuant = {},
16684 .data = TestBuffer::createFromVector<float>({1.0f}),
16685 .dimensions = {},
16686 .isIgnored = false,
16687 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16688 .numberOfConsumers = 1,
16689 .scale = 0.0f,
16690 .type = TestOperandType::FLOAT32,
16691 .zeroPoint = 0
16692 }, { // axis
16693 .channelQuant = {},
16694 .data = TestBuffer::createFromVector<int32_t>({0}),
16695 .dimensions = {},
16696 .isIgnored = false,
16697 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16698 .numberOfConsumers = 1,
16699 .scale = 0.0f,
16700 .type = TestOperandType::INT32,
16701 .zeroPoint = 0
16702 }, { // op2
16703 .channelQuant = {},
16704 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0}),
16705 .dimensions = {5},
16706 .isIgnored = false,
16707 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16708 .numberOfConsumers = 0,
16709 .scale = 0.00390625f,
16710 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16711 .zeroPoint = 0
16712 }},
16713 .operations = {{
16714 .inputs = {0, 1, 2},
16715 .outputs = {3},
16716 .type = TestOperationType::SOFTMAX
16717 }},
16718 .outputIndexes = {3}
16719 },
16720 .minSupportedVersion = TestHalVersion::V1_2,
16721 .referenced = {}
16722 };
16723 return model;
16724 }
16725
16726 const auto dummy_test_model_axis_quant8_dim1_axis0 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0", get_test_model_axis_quant8_dim1_axis0());
16727
16728 } // namespace generated_tests::softmax_v1_2
16729
16730 namespace generated_tests::softmax_v1_2 {
16731
get_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal()16732 const TestModel& get_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal() {
16733 static TestModel model = {
16734 .expectFailure = false,
16735 .expectedMultinomialDistributionTolerance = 0,
16736 .isRelaxed = false,
16737 .main = { // axis
16738 .inputIndexes = {4},
16739 .operands = {{ // op1
16740 .channelQuant = {},
16741 .data = TestBuffer::createFromVector<uint8_t>({}),
16742 .dimensions = {5},
16743 .isIgnored = false,
16744 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
16745 .numberOfConsumers = 1,
16746 .scale = 0.25f,
16747 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16748 .zeroPoint = 128
16749 }, { // param2
16750 .channelQuant = {},
16751 .data = TestBuffer::createFromVector<float>({1.0f}),
16752 .dimensions = {},
16753 .isIgnored = false,
16754 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16755 .numberOfConsumers = 1,
16756 .scale = 0.0f,
16757 .type = TestOperandType::FLOAT32,
16758 .zeroPoint = 0
16759 }, { // axis
16760 .channelQuant = {},
16761 .data = TestBuffer::createFromVector<int32_t>({0}),
16762 .dimensions = {},
16763 .isIgnored = false,
16764 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16765 .numberOfConsumers = 1,
16766 .scale = 0.0f,
16767 .type = TestOperandType::INT32,
16768 .zeroPoint = 0
16769 }, { // op2
16770 .channelQuant = {},
16771 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0}),
16772 .dimensions = {5},
16773 .isIgnored = false,
16774 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16775 .numberOfConsumers = 0,
16776 .scale = 0.00390625f,
16777 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16778 .zeroPoint = 0
16779 }, { // op1_new
16780 .channelQuant = {},
16781 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132}),
16782 .dimensions = {5},
16783 .isIgnored = false,
16784 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16785 .numberOfConsumers = 1,
16786 .scale = 0.25f,
16787 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16788 .zeroPoint = 128
16789 }, { // placeholder102
16790 .channelQuant = {},
16791 .data = TestBuffer::createFromVector<uint8_t>({128}),
16792 .dimensions = {1},
16793 .isIgnored = false,
16794 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16795 .numberOfConsumers = 1,
16796 .scale = 0.25f,
16797 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16798 .zeroPoint = 128
16799 }, { // param120
16800 .channelQuant = {},
16801 .data = TestBuffer::createFromVector<int32_t>({0}),
16802 .dimensions = {},
16803 .isIgnored = false,
16804 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16805 .numberOfConsumers = 1,
16806 .scale = 0.0f,
16807 .type = TestOperandType::INT32,
16808 .zeroPoint = 0
16809 }},
16810 .operations = {{
16811 .inputs = {4, 5, 6},
16812 .outputs = {0},
16813 .type = TestOperationType::ADD
16814 }, {
16815 .inputs = {0, 1, 2},
16816 .outputs = {3},
16817 .type = TestOperationType::SOFTMAX
16818 }},
16819 .outputIndexes = {3}
16820 },
16821 .minSupportedVersion = TestHalVersion::V1_2,
16822 .referenced = {}
16823 };
16824 return model;
16825 }
16826
16827 const auto dummy_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0_all_inputs_as_internal", get_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal());
16828
16829 } // namespace generated_tests::softmax_v1_2
16830
16831 namespace generated_tests::softmax_v1_2 {
16832
get_test_model_axis_quant8_dim1_axis0_neg()16833 const TestModel& get_test_model_axis_quant8_dim1_axis0_neg() {
16834 static TestModel model = {
16835 .expectFailure = false,
16836 .expectedMultinomialDistributionTolerance = 0,
16837 .isRelaxed = false,
16838 .main = { // axis
16839 .inputIndexes = {0},
16840 .operands = {{ // op1
16841 .channelQuant = {},
16842 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132}),
16843 .dimensions = {5},
16844 .isIgnored = false,
16845 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16846 .numberOfConsumers = 1,
16847 .scale = 0.25f,
16848 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16849 .zeroPoint = 128
16850 }, { // param2
16851 .channelQuant = {},
16852 .data = TestBuffer::createFromVector<float>({1.0f}),
16853 .dimensions = {},
16854 .isIgnored = false,
16855 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16856 .numberOfConsumers = 1,
16857 .scale = 0.0f,
16858 .type = TestOperandType::FLOAT32,
16859 .zeroPoint = 0
16860 }, { // axis
16861 .channelQuant = {},
16862 .data = TestBuffer::createFromVector<int32_t>({-1}),
16863 .dimensions = {},
16864 .isIgnored = false,
16865 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16866 .numberOfConsumers = 1,
16867 .scale = 0.0f,
16868 .type = TestOperandType::INT32,
16869 .zeroPoint = 0
16870 }, { // op2
16871 .channelQuant = {},
16872 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0}),
16873 .dimensions = {5},
16874 .isIgnored = false,
16875 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16876 .numberOfConsumers = 0,
16877 .scale = 0.00390625f,
16878 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16879 .zeroPoint = 0
16880 }},
16881 .operations = {{
16882 .inputs = {0, 1, 2},
16883 .outputs = {3},
16884 .type = TestOperationType::SOFTMAX
16885 }},
16886 .outputIndexes = {3}
16887 },
16888 .minSupportedVersion = TestHalVersion::V1_2,
16889 .referenced = {}
16890 };
16891 return model;
16892 }
16893
16894 const auto dummy_test_model_axis_quant8_dim1_axis0_neg = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0_neg", get_test_model_axis_quant8_dim1_axis0_neg());
16895
16896 } // namespace generated_tests::softmax_v1_2
16897
16898 namespace generated_tests::softmax_v1_2 {
16899
get_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal()16900 const TestModel& get_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal() {
16901 static TestModel model = {
16902 .expectFailure = false,
16903 .expectedMultinomialDistributionTolerance = 0,
16904 .isRelaxed = false,
16905 .main = { // axis
16906 .inputIndexes = {4},
16907 .operands = {{ // op1
16908 .channelQuant = {},
16909 .data = TestBuffer::createFromVector<uint8_t>({}),
16910 .dimensions = {5},
16911 .isIgnored = false,
16912 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
16913 .numberOfConsumers = 1,
16914 .scale = 0.25f,
16915 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16916 .zeroPoint = 128
16917 }, { // param2
16918 .channelQuant = {},
16919 .data = TestBuffer::createFromVector<float>({1.0f}),
16920 .dimensions = {},
16921 .isIgnored = false,
16922 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16923 .numberOfConsumers = 1,
16924 .scale = 0.0f,
16925 .type = TestOperandType::FLOAT32,
16926 .zeroPoint = 0
16927 }, { // axis
16928 .channelQuant = {},
16929 .data = TestBuffer::createFromVector<int32_t>({-1}),
16930 .dimensions = {},
16931 .isIgnored = false,
16932 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16933 .numberOfConsumers = 1,
16934 .scale = 0.0f,
16935 .type = TestOperandType::INT32,
16936 .zeroPoint = 0
16937 }, { // op2
16938 .channelQuant = {},
16939 .data = TestBuffer::createFromVector<uint8_t>({165, 61, 22, 8, 0}),
16940 .dimensions = {5},
16941 .isIgnored = false,
16942 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
16943 .numberOfConsumers = 0,
16944 .scale = 0.00390625f,
16945 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16946 .zeroPoint = 0
16947 }, { // op1_new
16948 .channelQuant = {},
16949 .data = TestBuffer::createFromVector<uint8_t>({196, 192, 188, 184, 132}),
16950 .dimensions = {5},
16951 .isIgnored = false,
16952 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
16953 .numberOfConsumers = 1,
16954 .scale = 0.25f,
16955 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16956 .zeroPoint = 128
16957 }, { // placeholder103
16958 .channelQuant = {},
16959 .data = TestBuffer::createFromVector<uint8_t>({128}),
16960 .dimensions = {1},
16961 .isIgnored = false,
16962 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16963 .numberOfConsumers = 1,
16964 .scale = 0.25f,
16965 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
16966 .zeroPoint = 128
16967 }, { // param121
16968 .channelQuant = {},
16969 .data = TestBuffer::createFromVector<int32_t>({0}),
16970 .dimensions = {},
16971 .isIgnored = false,
16972 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
16973 .numberOfConsumers = 1,
16974 .scale = 0.0f,
16975 .type = TestOperandType::INT32,
16976 .zeroPoint = 0
16977 }},
16978 .operations = {{
16979 .inputs = {4, 5, 6},
16980 .outputs = {0},
16981 .type = TestOperationType::ADD
16982 }, {
16983 .inputs = {0, 1, 2},
16984 .outputs = {3},
16985 .type = TestOperationType::SOFTMAX
16986 }},
16987 .outputIndexes = {3}
16988 },
16989 .minSupportedVersion = TestHalVersion::V1_2,
16990 .referenced = {}
16991 };
16992 return model;
16993 }
16994
16995 const auto dummy_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0_neg_all_inputs_as_internal", get_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal());
16996
16997 } // namespace generated_tests::softmax_v1_2
16998
16999 namespace generated_tests::softmax_v1_2 {
17000
get_test_model_axis_dim4_axis0_2()17001 const TestModel& get_test_model_axis_dim4_axis0_2() {
17002 static TestModel model = {
17003 .expectFailure = false,
17004 .expectedMultinomialDistributionTolerance = 0,
17005 .isRelaxed = false,
17006 .main = { // axis
17007 .inputIndexes = {0},
17008 .operands = {{ // op1
17009 .channelQuant = {},
17010 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17011 .dimensions = {5, 2, 2, 2},
17012 .isIgnored = false,
17013 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17014 .numberOfConsumers = 1,
17015 .scale = 0.0f,
17016 .type = TestOperandType::TENSOR_FLOAT32,
17017 .zeroPoint = 0
17018 }, { // param3
17019 .channelQuant = {},
17020 .data = TestBuffer::createFromVector<float>({1e-06f}),
17021 .dimensions = {},
17022 .isIgnored = false,
17023 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17024 .numberOfConsumers = 1,
17025 .scale = 0.0f,
17026 .type = TestOperandType::FLOAT32,
17027 .zeroPoint = 0
17028 }, { // axis
17029 .channelQuant = {},
17030 .data = TestBuffer::createFromVector<int32_t>({0}),
17031 .dimensions = {},
17032 .isIgnored = false,
17033 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17034 .numberOfConsumers = 1,
17035 .scale = 0.0f,
17036 .type = TestOperandType::INT32,
17037 .zeroPoint = 0
17038 }, { // op2
17039 .channelQuant = {},
17040 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17041 .dimensions = {5, 2, 2, 2},
17042 .isIgnored = false,
17043 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17044 .numberOfConsumers = 0,
17045 .scale = 0.0f,
17046 .type = TestOperandType::TENSOR_FLOAT32,
17047 .zeroPoint = 0
17048 }},
17049 .operations = {{
17050 .inputs = {0, 1, 2},
17051 .outputs = {3},
17052 .type = TestOperationType::SOFTMAX
17053 }},
17054 .outputIndexes = {3}
17055 },
17056 .minSupportedVersion = TestHalVersion::V1_2,
17057 .referenced = {}
17058 };
17059 return model;
17060 }
17061
17062 const auto dummy_test_model_axis_dim4_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0_2", get_test_model_axis_dim4_axis0_2());
17063
17064 } // namespace generated_tests::softmax_v1_2
17065
17066 namespace generated_tests::softmax_v1_2 {
17067
get_test_model_axis_dim4_axis0_all_inputs_as_internal_2()17068 const TestModel& get_test_model_axis_dim4_axis0_all_inputs_as_internal_2() {
17069 static TestModel model = {
17070 .expectFailure = false,
17071 .expectedMultinomialDistributionTolerance = 0,
17072 .isRelaxed = false,
17073 .main = { // axis
17074 .inputIndexes = {4},
17075 .operands = {{ // op1
17076 .channelQuant = {},
17077 .data = TestBuffer::createFromVector<float>({}),
17078 .dimensions = {5, 2, 2, 2},
17079 .isIgnored = false,
17080 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
17081 .numberOfConsumers = 1,
17082 .scale = 0.0f,
17083 .type = TestOperandType::TENSOR_FLOAT32,
17084 .zeroPoint = 0
17085 }, { // param3
17086 .channelQuant = {},
17087 .data = TestBuffer::createFromVector<float>({1e-06f}),
17088 .dimensions = {},
17089 .isIgnored = false,
17090 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17091 .numberOfConsumers = 1,
17092 .scale = 0.0f,
17093 .type = TestOperandType::FLOAT32,
17094 .zeroPoint = 0
17095 }, { // axis
17096 .channelQuant = {},
17097 .data = TestBuffer::createFromVector<int32_t>({0}),
17098 .dimensions = {},
17099 .isIgnored = false,
17100 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17101 .numberOfConsumers = 1,
17102 .scale = 0.0f,
17103 .type = TestOperandType::INT32,
17104 .zeroPoint = 0
17105 }, { // op2
17106 .channelQuant = {},
17107 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17108 .dimensions = {5, 2, 2, 2},
17109 .isIgnored = false,
17110 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17111 .numberOfConsumers = 0,
17112 .scale = 0.0f,
17113 .type = TestOperandType::TENSOR_FLOAT32,
17114 .zeroPoint = 0
17115 }, { // op1_new
17116 .channelQuant = {},
17117 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17118 .dimensions = {5, 2, 2, 2},
17119 .isIgnored = false,
17120 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17121 .numberOfConsumers = 1,
17122 .scale = 0.0f,
17123 .type = TestOperandType::TENSOR_FLOAT32,
17124 .zeroPoint = 0
17125 }, { // placeholder104
17126 .channelQuant = {},
17127 .data = TestBuffer::createFromVector<float>({0.0f}),
17128 .dimensions = {1},
17129 .isIgnored = false,
17130 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17131 .numberOfConsumers = 1,
17132 .scale = 0.0f,
17133 .type = TestOperandType::TENSOR_FLOAT32,
17134 .zeroPoint = 0
17135 }, { // param122
17136 .channelQuant = {},
17137 .data = TestBuffer::createFromVector<int32_t>({0}),
17138 .dimensions = {},
17139 .isIgnored = false,
17140 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17141 .numberOfConsumers = 1,
17142 .scale = 0.0f,
17143 .type = TestOperandType::INT32,
17144 .zeroPoint = 0
17145 }},
17146 .operations = {{
17147 .inputs = {4, 5, 6},
17148 .outputs = {0},
17149 .type = TestOperationType::ADD
17150 }, {
17151 .inputs = {0, 1, 2},
17152 .outputs = {3},
17153 .type = TestOperationType::SOFTMAX
17154 }},
17155 .outputIndexes = {3}
17156 },
17157 .minSupportedVersion = TestHalVersion::V1_2,
17158 .referenced = {}
17159 };
17160 return model;
17161 }
17162
17163 const auto dummy_test_model_axis_dim4_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0_all_inputs_as_internal_2", get_test_model_axis_dim4_axis0_all_inputs_as_internal_2());
17164
17165 } // namespace generated_tests::softmax_v1_2
17166
17167 namespace generated_tests::softmax_v1_2 {
17168
get_test_model_axis_dim4_axis0_neg_2()17169 const TestModel& get_test_model_axis_dim4_axis0_neg_2() {
17170 static TestModel model = {
17171 .expectFailure = false,
17172 .expectedMultinomialDistributionTolerance = 0,
17173 .isRelaxed = false,
17174 .main = { // axis
17175 .inputIndexes = {0},
17176 .operands = {{ // op1
17177 .channelQuant = {},
17178 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17179 .dimensions = {5, 2, 2, 2},
17180 .isIgnored = false,
17181 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17182 .numberOfConsumers = 1,
17183 .scale = 0.0f,
17184 .type = TestOperandType::TENSOR_FLOAT32,
17185 .zeroPoint = 0
17186 }, { // param3
17187 .channelQuant = {},
17188 .data = TestBuffer::createFromVector<float>({1e-06f}),
17189 .dimensions = {},
17190 .isIgnored = false,
17191 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17192 .numberOfConsumers = 1,
17193 .scale = 0.0f,
17194 .type = TestOperandType::FLOAT32,
17195 .zeroPoint = 0
17196 }, { // axis
17197 .channelQuant = {},
17198 .data = TestBuffer::createFromVector<int32_t>({-4}),
17199 .dimensions = {},
17200 .isIgnored = false,
17201 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17202 .numberOfConsumers = 1,
17203 .scale = 0.0f,
17204 .type = TestOperandType::INT32,
17205 .zeroPoint = 0
17206 }, { // op2
17207 .channelQuant = {},
17208 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17209 .dimensions = {5, 2, 2, 2},
17210 .isIgnored = false,
17211 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17212 .numberOfConsumers = 0,
17213 .scale = 0.0f,
17214 .type = TestOperandType::TENSOR_FLOAT32,
17215 .zeroPoint = 0
17216 }},
17217 .operations = {{
17218 .inputs = {0, 1, 2},
17219 .outputs = {3},
17220 .type = TestOperationType::SOFTMAX
17221 }},
17222 .outputIndexes = {3}
17223 },
17224 .minSupportedVersion = TestHalVersion::V1_2,
17225 .referenced = {}
17226 };
17227 return model;
17228 }
17229
17230 const auto dummy_test_model_axis_dim4_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0_neg_2", get_test_model_axis_dim4_axis0_neg_2());
17231
17232 } // namespace generated_tests::softmax_v1_2
17233
17234 namespace generated_tests::softmax_v1_2 {
17235
get_test_model_axis_dim4_axis0_neg_all_inputs_as_internal_2()17236 const TestModel& get_test_model_axis_dim4_axis0_neg_all_inputs_as_internal_2() {
17237 static TestModel model = {
17238 .expectFailure = false,
17239 .expectedMultinomialDistributionTolerance = 0,
17240 .isRelaxed = false,
17241 .main = { // axis
17242 .inputIndexes = {4},
17243 .operands = {{ // op1
17244 .channelQuant = {},
17245 .data = TestBuffer::createFromVector<float>({}),
17246 .dimensions = {5, 2, 2, 2},
17247 .isIgnored = false,
17248 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
17249 .numberOfConsumers = 1,
17250 .scale = 0.0f,
17251 .type = TestOperandType::TENSOR_FLOAT32,
17252 .zeroPoint = 0
17253 }, { // param3
17254 .channelQuant = {},
17255 .data = TestBuffer::createFromVector<float>({1e-06f}),
17256 .dimensions = {},
17257 .isIgnored = false,
17258 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17259 .numberOfConsumers = 1,
17260 .scale = 0.0f,
17261 .type = TestOperandType::FLOAT32,
17262 .zeroPoint = 0
17263 }, { // axis
17264 .channelQuant = {},
17265 .data = TestBuffer::createFromVector<int32_t>({-4}),
17266 .dimensions = {},
17267 .isIgnored = false,
17268 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17269 .numberOfConsumers = 1,
17270 .scale = 0.0f,
17271 .type = TestOperandType::INT32,
17272 .zeroPoint = 0
17273 }, { // op2
17274 .channelQuant = {},
17275 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17276 .dimensions = {5, 2, 2, 2},
17277 .isIgnored = false,
17278 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17279 .numberOfConsumers = 0,
17280 .scale = 0.0f,
17281 .type = TestOperandType::TENSOR_FLOAT32,
17282 .zeroPoint = 0
17283 }, { // op1_new
17284 .channelQuant = {},
17285 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17286 .dimensions = {5, 2, 2, 2},
17287 .isIgnored = false,
17288 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17289 .numberOfConsumers = 1,
17290 .scale = 0.0f,
17291 .type = TestOperandType::TENSOR_FLOAT32,
17292 .zeroPoint = 0
17293 }, { // placeholder105
17294 .channelQuant = {},
17295 .data = TestBuffer::createFromVector<float>({0.0f}),
17296 .dimensions = {1},
17297 .isIgnored = false,
17298 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17299 .numberOfConsumers = 1,
17300 .scale = 0.0f,
17301 .type = TestOperandType::TENSOR_FLOAT32,
17302 .zeroPoint = 0
17303 }, { // param123
17304 .channelQuant = {},
17305 .data = TestBuffer::createFromVector<int32_t>({0}),
17306 .dimensions = {},
17307 .isIgnored = false,
17308 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17309 .numberOfConsumers = 1,
17310 .scale = 0.0f,
17311 .type = TestOperandType::INT32,
17312 .zeroPoint = 0
17313 }},
17314 .operations = {{
17315 .inputs = {4, 5, 6},
17316 .outputs = {0},
17317 .type = TestOperationType::ADD
17318 }, {
17319 .inputs = {0, 1, 2},
17320 .outputs = {3},
17321 .type = TestOperationType::SOFTMAX
17322 }},
17323 .outputIndexes = {3}
17324 },
17325 .minSupportedVersion = TestHalVersion::V1_2,
17326 .referenced = {}
17327 };
17328 return model;
17329 }
17330
17331 const auto dummy_test_model_axis_dim4_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_dim4_axis0_neg_all_inputs_as_internal_2());
17332
17333 } // namespace generated_tests::softmax_v1_2
17334
17335 namespace generated_tests::softmax_v1_2 {
17336
get_test_model_axis_dim4_axis1_2()17337 const TestModel& get_test_model_axis_dim4_axis1_2() {
17338 static TestModel model = {
17339 .expectFailure = false,
17340 .expectedMultinomialDistributionTolerance = 0,
17341 .isRelaxed = false,
17342 .main = { // axis
17343 .inputIndexes = {0},
17344 .operands = {{ // op1
17345 .channelQuant = {},
17346 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17347 .dimensions = {2, 5, 2, 2},
17348 .isIgnored = false,
17349 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17350 .numberOfConsumers = 1,
17351 .scale = 0.0f,
17352 .type = TestOperandType::TENSOR_FLOAT32,
17353 .zeroPoint = 0
17354 }, { // param3
17355 .channelQuant = {},
17356 .data = TestBuffer::createFromVector<float>({1e-06f}),
17357 .dimensions = {},
17358 .isIgnored = false,
17359 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17360 .numberOfConsumers = 1,
17361 .scale = 0.0f,
17362 .type = TestOperandType::FLOAT32,
17363 .zeroPoint = 0
17364 }, { // axis
17365 .channelQuant = {},
17366 .data = TestBuffer::createFromVector<int32_t>({1}),
17367 .dimensions = {},
17368 .isIgnored = false,
17369 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17370 .numberOfConsumers = 1,
17371 .scale = 0.0f,
17372 .type = TestOperandType::INT32,
17373 .zeroPoint = 0
17374 }, { // op2
17375 .channelQuant = {},
17376 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17377 .dimensions = {2, 5, 2, 2},
17378 .isIgnored = false,
17379 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17380 .numberOfConsumers = 0,
17381 .scale = 0.0f,
17382 .type = TestOperandType::TENSOR_FLOAT32,
17383 .zeroPoint = 0
17384 }},
17385 .operations = {{
17386 .inputs = {0, 1, 2},
17387 .outputs = {3},
17388 .type = TestOperationType::SOFTMAX
17389 }},
17390 .outputIndexes = {3}
17391 },
17392 .minSupportedVersion = TestHalVersion::V1_2,
17393 .referenced = {}
17394 };
17395 return model;
17396 }
17397
17398 const auto dummy_test_model_axis_dim4_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1_2", get_test_model_axis_dim4_axis1_2());
17399
17400 } // namespace generated_tests::softmax_v1_2
17401
17402 namespace generated_tests::softmax_v1_2 {
17403
get_test_model_axis_dim4_axis1_all_inputs_as_internal_2()17404 const TestModel& get_test_model_axis_dim4_axis1_all_inputs_as_internal_2() {
17405 static TestModel model = {
17406 .expectFailure = false,
17407 .expectedMultinomialDistributionTolerance = 0,
17408 .isRelaxed = false,
17409 .main = { // axis
17410 .inputIndexes = {4},
17411 .operands = {{ // op1
17412 .channelQuant = {},
17413 .data = TestBuffer::createFromVector<float>({}),
17414 .dimensions = {2, 5, 2, 2},
17415 .isIgnored = false,
17416 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
17417 .numberOfConsumers = 1,
17418 .scale = 0.0f,
17419 .type = TestOperandType::TENSOR_FLOAT32,
17420 .zeroPoint = 0
17421 }, { // param3
17422 .channelQuant = {},
17423 .data = TestBuffer::createFromVector<float>({1e-06f}),
17424 .dimensions = {},
17425 .isIgnored = false,
17426 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17427 .numberOfConsumers = 1,
17428 .scale = 0.0f,
17429 .type = TestOperandType::FLOAT32,
17430 .zeroPoint = 0
17431 }, { // axis
17432 .channelQuant = {},
17433 .data = TestBuffer::createFromVector<int32_t>({1}),
17434 .dimensions = {},
17435 .isIgnored = false,
17436 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17437 .numberOfConsumers = 1,
17438 .scale = 0.0f,
17439 .type = TestOperandType::INT32,
17440 .zeroPoint = 0
17441 }, { // op2
17442 .channelQuant = {},
17443 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17444 .dimensions = {2, 5, 2, 2},
17445 .isIgnored = false,
17446 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17447 .numberOfConsumers = 0,
17448 .scale = 0.0f,
17449 .type = TestOperandType::TENSOR_FLOAT32,
17450 .zeroPoint = 0
17451 }, { // op1_new
17452 .channelQuant = {},
17453 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17454 .dimensions = {2, 5, 2, 2},
17455 .isIgnored = false,
17456 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17457 .numberOfConsumers = 1,
17458 .scale = 0.0f,
17459 .type = TestOperandType::TENSOR_FLOAT32,
17460 .zeroPoint = 0
17461 }, { // placeholder106
17462 .channelQuant = {},
17463 .data = TestBuffer::createFromVector<float>({0.0f}),
17464 .dimensions = {1},
17465 .isIgnored = false,
17466 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17467 .numberOfConsumers = 1,
17468 .scale = 0.0f,
17469 .type = TestOperandType::TENSOR_FLOAT32,
17470 .zeroPoint = 0
17471 }, { // param124
17472 .channelQuant = {},
17473 .data = TestBuffer::createFromVector<int32_t>({0}),
17474 .dimensions = {},
17475 .isIgnored = false,
17476 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17477 .numberOfConsumers = 1,
17478 .scale = 0.0f,
17479 .type = TestOperandType::INT32,
17480 .zeroPoint = 0
17481 }},
17482 .operations = {{
17483 .inputs = {4, 5, 6},
17484 .outputs = {0},
17485 .type = TestOperationType::ADD
17486 }, {
17487 .inputs = {0, 1, 2},
17488 .outputs = {3},
17489 .type = TestOperationType::SOFTMAX
17490 }},
17491 .outputIndexes = {3}
17492 },
17493 .minSupportedVersion = TestHalVersion::V1_2,
17494 .referenced = {}
17495 };
17496 return model;
17497 }
17498
17499 const auto dummy_test_model_axis_dim4_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1_all_inputs_as_internal_2", get_test_model_axis_dim4_axis1_all_inputs_as_internal_2());
17500
17501 } // namespace generated_tests::softmax_v1_2
17502
17503 namespace generated_tests::softmax_v1_2 {
17504
get_test_model_axis_dim4_axis1_neg_2()17505 const TestModel& get_test_model_axis_dim4_axis1_neg_2() {
17506 static TestModel model = {
17507 .expectFailure = false,
17508 .expectedMultinomialDistributionTolerance = 0,
17509 .isRelaxed = false,
17510 .main = { // axis
17511 .inputIndexes = {0},
17512 .operands = {{ // op1
17513 .channelQuant = {},
17514 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17515 .dimensions = {2, 5, 2, 2},
17516 .isIgnored = false,
17517 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17518 .numberOfConsumers = 1,
17519 .scale = 0.0f,
17520 .type = TestOperandType::TENSOR_FLOAT32,
17521 .zeroPoint = 0
17522 }, { // param3
17523 .channelQuant = {},
17524 .data = TestBuffer::createFromVector<float>({1e-06f}),
17525 .dimensions = {},
17526 .isIgnored = false,
17527 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17528 .numberOfConsumers = 1,
17529 .scale = 0.0f,
17530 .type = TestOperandType::FLOAT32,
17531 .zeroPoint = 0
17532 }, { // axis
17533 .channelQuant = {},
17534 .data = TestBuffer::createFromVector<int32_t>({-3}),
17535 .dimensions = {},
17536 .isIgnored = false,
17537 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17538 .numberOfConsumers = 1,
17539 .scale = 0.0f,
17540 .type = TestOperandType::INT32,
17541 .zeroPoint = 0
17542 }, { // op2
17543 .channelQuant = {},
17544 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17545 .dimensions = {2, 5, 2, 2},
17546 .isIgnored = false,
17547 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17548 .numberOfConsumers = 0,
17549 .scale = 0.0f,
17550 .type = TestOperandType::TENSOR_FLOAT32,
17551 .zeroPoint = 0
17552 }},
17553 .operations = {{
17554 .inputs = {0, 1, 2},
17555 .outputs = {3},
17556 .type = TestOperationType::SOFTMAX
17557 }},
17558 .outputIndexes = {3}
17559 },
17560 .minSupportedVersion = TestHalVersion::V1_2,
17561 .referenced = {}
17562 };
17563 return model;
17564 }
17565
17566 const auto dummy_test_model_axis_dim4_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1_neg_2", get_test_model_axis_dim4_axis1_neg_2());
17567
17568 } // namespace generated_tests::softmax_v1_2
17569
17570 namespace generated_tests::softmax_v1_2 {
17571
get_test_model_axis_dim4_axis1_neg_all_inputs_as_internal_2()17572 const TestModel& get_test_model_axis_dim4_axis1_neg_all_inputs_as_internal_2() {
17573 static TestModel model = {
17574 .expectFailure = false,
17575 .expectedMultinomialDistributionTolerance = 0,
17576 .isRelaxed = false,
17577 .main = { // axis
17578 .inputIndexes = {4},
17579 .operands = {{ // op1
17580 .channelQuant = {},
17581 .data = TestBuffer::createFromVector<float>({}),
17582 .dimensions = {2, 5, 2, 2},
17583 .isIgnored = false,
17584 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
17585 .numberOfConsumers = 1,
17586 .scale = 0.0f,
17587 .type = TestOperandType::TENSOR_FLOAT32,
17588 .zeroPoint = 0
17589 }, { // param3
17590 .channelQuant = {},
17591 .data = TestBuffer::createFromVector<float>({1e-06f}),
17592 .dimensions = {},
17593 .isIgnored = false,
17594 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17595 .numberOfConsumers = 1,
17596 .scale = 0.0f,
17597 .type = TestOperandType::FLOAT32,
17598 .zeroPoint = 0
17599 }, { // axis
17600 .channelQuant = {},
17601 .data = TestBuffer::createFromVector<int32_t>({-3}),
17602 .dimensions = {},
17603 .isIgnored = false,
17604 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17605 .numberOfConsumers = 1,
17606 .scale = 0.0f,
17607 .type = TestOperandType::INT32,
17608 .zeroPoint = 0
17609 }, { // op2
17610 .channelQuant = {},
17611 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17612 .dimensions = {2, 5, 2, 2},
17613 .isIgnored = false,
17614 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17615 .numberOfConsumers = 0,
17616 .scale = 0.0f,
17617 .type = TestOperandType::TENSOR_FLOAT32,
17618 .zeroPoint = 0
17619 }, { // op1_new
17620 .channelQuant = {},
17621 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
17622 .dimensions = {2, 5, 2, 2},
17623 .isIgnored = false,
17624 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17625 .numberOfConsumers = 1,
17626 .scale = 0.0f,
17627 .type = TestOperandType::TENSOR_FLOAT32,
17628 .zeroPoint = 0
17629 }, { // placeholder107
17630 .channelQuant = {},
17631 .data = TestBuffer::createFromVector<float>({0.0f}),
17632 .dimensions = {1},
17633 .isIgnored = false,
17634 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17635 .numberOfConsumers = 1,
17636 .scale = 0.0f,
17637 .type = TestOperandType::TENSOR_FLOAT32,
17638 .zeroPoint = 0
17639 }, { // param125
17640 .channelQuant = {},
17641 .data = TestBuffer::createFromVector<int32_t>({0}),
17642 .dimensions = {},
17643 .isIgnored = false,
17644 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17645 .numberOfConsumers = 1,
17646 .scale = 0.0f,
17647 .type = TestOperandType::INT32,
17648 .zeroPoint = 0
17649 }},
17650 .operations = {{
17651 .inputs = {4, 5, 6},
17652 .outputs = {0},
17653 .type = TestOperationType::ADD
17654 }, {
17655 .inputs = {0, 1, 2},
17656 .outputs = {3},
17657 .type = TestOperationType::SOFTMAX
17658 }},
17659 .outputIndexes = {3}
17660 },
17661 .minSupportedVersion = TestHalVersion::V1_2,
17662 .referenced = {}
17663 };
17664 return model;
17665 }
17666
17667 const auto dummy_test_model_axis_dim4_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_dim4_axis1_neg_all_inputs_as_internal_2());
17668
17669 } // namespace generated_tests::softmax_v1_2
17670
17671 namespace generated_tests::softmax_v1_2 {
17672
get_test_model_axis_dim4_axis2_2()17673 const TestModel& get_test_model_axis_dim4_axis2_2() {
17674 static TestModel model = {
17675 .expectFailure = false,
17676 .expectedMultinomialDistributionTolerance = 0,
17677 .isRelaxed = false,
17678 .main = { // axis
17679 .inputIndexes = {0},
17680 .operands = {{ // op1
17681 .channelQuant = {},
17682 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
17683 .dimensions = {2, 2, 5, 2},
17684 .isIgnored = false,
17685 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17686 .numberOfConsumers = 1,
17687 .scale = 0.0f,
17688 .type = TestOperandType::TENSOR_FLOAT32,
17689 .zeroPoint = 0
17690 }, { // param3
17691 .channelQuant = {},
17692 .data = TestBuffer::createFromVector<float>({1e-06f}),
17693 .dimensions = {},
17694 .isIgnored = false,
17695 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17696 .numberOfConsumers = 1,
17697 .scale = 0.0f,
17698 .type = TestOperandType::FLOAT32,
17699 .zeroPoint = 0
17700 }, { // axis
17701 .channelQuant = {},
17702 .data = TestBuffer::createFromVector<int32_t>({2}),
17703 .dimensions = {},
17704 .isIgnored = false,
17705 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17706 .numberOfConsumers = 1,
17707 .scale = 0.0f,
17708 .type = TestOperandType::INT32,
17709 .zeroPoint = 0
17710 }, { // op2
17711 .channelQuant = {},
17712 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17713 .dimensions = {2, 2, 5, 2},
17714 .isIgnored = false,
17715 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17716 .numberOfConsumers = 0,
17717 .scale = 0.0f,
17718 .type = TestOperandType::TENSOR_FLOAT32,
17719 .zeroPoint = 0
17720 }},
17721 .operations = {{
17722 .inputs = {0, 1, 2},
17723 .outputs = {3},
17724 .type = TestOperationType::SOFTMAX
17725 }},
17726 .outputIndexes = {3}
17727 },
17728 .minSupportedVersion = TestHalVersion::V1_2,
17729 .referenced = {}
17730 };
17731 return model;
17732 }
17733
17734 const auto dummy_test_model_axis_dim4_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2_2", get_test_model_axis_dim4_axis2_2());
17735
17736 } // namespace generated_tests::softmax_v1_2
17737
17738 namespace generated_tests::softmax_v1_2 {
17739
get_test_model_axis_dim4_axis2_all_inputs_as_internal_2()17740 const TestModel& get_test_model_axis_dim4_axis2_all_inputs_as_internal_2() {
17741 static TestModel model = {
17742 .expectFailure = false,
17743 .expectedMultinomialDistributionTolerance = 0,
17744 .isRelaxed = false,
17745 .main = { // axis
17746 .inputIndexes = {4},
17747 .operands = {{ // op1
17748 .channelQuant = {},
17749 .data = TestBuffer::createFromVector<float>({}),
17750 .dimensions = {2, 2, 5, 2},
17751 .isIgnored = false,
17752 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
17753 .numberOfConsumers = 1,
17754 .scale = 0.0f,
17755 .type = TestOperandType::TENSOR_FLOAT32,
17756 .zeroPoint = 0
17757 }, { // param3
17758 .channelQuant = {},
17759 .data = TestBuffer::createFromVector<float>({1e-06f}),
17760 .dimensions = {},
17761 .isIgnored = false,
17762 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17763 .numberOfConsumers = 1,
17764 .scale = 0.0f,
17765 .type = TestOperandType::FLOAT32,
17766 .zeroPoint = 0
17767 }, { // axis
17768 .channelQuant = {},
17769 .data = TestBuffer::createFromVector<int32_t>({2}),
17770 .dimensions = {},
17771 .isIgnored = false,
17772 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17773 .numberOfConsumers = 1,
17774 .scale = 0.0f,
17775 .type = TestOperandType::INT32,
17776 .zeroPoint = 0
17777 }, { // op2
17778 .channelQuant = {},
17779 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17780 .dimensions = {2, 2, 5, 2},
17781 .isIgnored = false,
17782 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17783 .numberOfConsumers = 0,
17784 .scale = 0.0f,
17785 .type = TestOperandType::TENSOR_FLOAT32,
17786 .zeroPoint = 0
17787 }, { // op1_new
17788 .channelQuant = {},
17789 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
17790 .dimensions = {2, 2, 5, 2},
17791 .isIgnored = false,
17792 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17793 .numberOfConsumers = 1,
17794 .scale = 0.0f,
17795 .type = TestOperandType::TENSOR_FLOAT32,
17796 .zeroPoint = 0
17797 }, { // placeholder108
17798 .channelQuant = {},
17799 .data = TestBuffer::createFromVector<float>({0.0f}),
17800 .dimensions = {1},
17801 .isIgnored = false,
17802 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17803 .numberOfConsumers = 1,
17804 .scale = 0.0f,
17805 .type = TestOperandType::TENSOR_FLOAT32,
17806 .zeroPoint = 0
17807 }, { // param126
17808 .channelQuant = {},
17809 .data = TestBuffer::createFromVector<int32_t>({0}),
17810 .dimensions = {},
17811 .isIgnored = false,
17812 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17813 .numberOfConsumers = 1,
17814 .scale = 0.0f,
17815 .type = TestOperandType::INT32,
17816 .zeroPoint = 0
17817 }},
17818 .operations = {{
17819 .inputs = {4, 5, 6},
17820 .outputs = {0},
17821 .type = TestOperationType::ADD
17822 }, {
17823 .inputs = {0, 1, 2},
17824 .outputs = {3},
17825 .type = TestOperationType::SOFTMAX
17826 }},
17827 .outputIndexes = {3}
17828 },
17829 .minSupportedVersion = TestHalVersion::V1_2,
17830 .referenced = {}
17831 };
17832 return model;
17833 }
17834
17835 const auto dummy_test_model_axis_dim4_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2_all_inputs_as_internal_2", get_test_model_axis_dim4_axis2_all_inputs_as_internal_2());
17836
17837 } // namespace generated_tests::softmax_v1_2
17838
17839 namespace generated_tests::softmax_v1_2 {
17840
get_test_model_axis_dim4_axis2_neg_2()17841 const TestModel& get_test_model_axis_dim4_axis2_neg_2() {
17842 static TestModel model = {
17843 .expectFailure = false,
17844 .expectedMultinomialDistributionTolerance = 0,
17845 .isRelaxed = false,
17846 .main = { // axis
17847 .inputIndexes = {0},
17848 .operands = {{ // op1
17849 .channelQuant = {},
17850 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
17851 .dimensions = {2, 2, 5, 2},
17852 .isIgnored = false,
17853 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17854 .numberOfConsumers = 1,
17855 .scale = 0.0f,
17856 .type = TestOperandType::TENSOR_FLOAT32,
17857 .zeroPoint = 0
17858 }, { // param3
17859 .channelQuant = {},
17860 .data = TestBuffer::createFromVector<float>({1e-06f}),
17861 .dimensions = {},
17862 .isIgnored = false,
17863 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17864 .numberOfConsumers = 1,
17865 .scale = 0.0f,
17866 .type = TestOperandType::FLOAT32,
17867 .zeroPoint = 0
17868 }, { // axis
17869 .channelQuant = {},
17870 .data = TestBuffer::createFromVector<int32_t>({-2}),
17871 .dimensions = {},
17872 .isIgnored = false,
17873 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17874 .numberOfConsumers = 1,
17875 .scale = 0.0f,
17876 .type = TestOperandType::INT32,
17877 .zeroPoint = 0
17878 }, { // op2
17879 .channelQuant = {},
17880 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17881 .dimensions = {2, 2, 5, 2},
17882 .isIgnored = false,
17883 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17884 .numberOfConsumers = 0,
17885 .scale = 0.0f,
17886 .type = TestOperandType::TENSOR_FLOAT32,
17887 .zeroPoint = 0
17888 }},
17889 .operations = {{
17890 .inputs = {0, 1, 2},
17891 .outputs = {3},
17892 .type = TestOperationType::SOFTMAX
17893 }},
17894 .outputIndexes = {3}
17895 },
17896 .minSupportedVersion = TestHalVersion::V1_2,
17897 .referenced = {}
17898 };
17899 return model;
17900 }
17901
17902 const auto dummy_test_model_axis_dim4_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2_neg_2", get_test_model_axis_dim4_axis2_neg_2());
17903
17904 } // namespace generated_tests::softmax_v1_2
17905
17906 namespace generated_tests::softmax_v1_2 {
17907
get_test_model_axis_dim4_axis2_neg_all_inputs_as_internal_2()17908 const TestModel& get_test_model_axis_dim4_axis2_neg_all_inputs_as_internal_2() {
17909 static TestModel model = {
17910 .expectFailure = false,
17911 .expectedMultinomialDistributionTolerance = 0,
17912 .isRelaxed = false,
17913 .main = { // axis
17914 .inputIndexes = {4},
17915 .operands = {{ // op1
17916 .channelQuant = {},
17917 .data = TestBuffer::createFromVector<float>({}),
17918 .dimensions = {2, 2, 5, 2},
17919 .isIgnored = false,
17920 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
17921 .numberOfConsumers = 1,
17922 .scale = 0.0f,
17923 .type = TestOperandType::TENSOR_FLOAT32,
17924 .zeroPoint = 0
17925 }, { // param3
17926 .channelQuant = {},
17927 .data = TestBuffer::createFromVector<float>({1e-06f}),
17928 .dimensions = {},
17929 .isIgnored = false,
17930 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17931 .numberOfConsumers = 1,
17932 .scale = 0.0f,
17933 .type = TestOperandType::FLOAT32,
17934 .zeroPoint = 0
17935 }, { // axis
17936 .channelQuant = {},
17937 .data = TestBuffer::createFromVector<int32_t>({-2}),
17938 .dimensions = {},
17939 .isIgnored = false,
17940 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17941 .numberOfConsumers = 1,
17942 .scale = 0.0f,
17943 .type = TestOperandType::INT32,
17944 .zeroPoint = 0
17945 }, { // op2
17946 .channelQuant = {},
17947 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
17948 .dimensions = {2, 2, 5, 2},
17949 .isIgnored = false,
17950 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
17951 .numberOfConsumers = 0,
17952 .scale = 0.0f,
17953 .type = TestOperandType::TENSOR_FLOAT32,
17954 .zeroPoint = 0
17955 }, { // op1_new
17956 .channelQuant = {},
17957 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
17958 .dimensions = {2, 2, 5, 2},
17959 .isIgnored = false,
17960 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
17961 .numberOfConsumers = 1,
17962 .scale = 0.0f,
17963 .type = TestOperandType::TENSOR_FLOAT32,
17964 .zeroPoint = 0
17965 }, { // placeholder109
17966 .channelQuant = {},
17967 .data = TestBuffer::createFromVector<float>({0.0f}),
17968 .dimensions = {1},
17969 .isIgnored = false,
17970 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17971 .numberOfConsumers = 1,
17972 .scale = 0.0f,
17973 .type = TestOperandType::TENSOR_FLOAT32,
17974 .zeroPoint = 0
17975 }, { // param127
17976 .channelQuant = {},
17977 .data = TestBuffer::createFromVector<int32_t>({0}),
17978 .dimensions = {},
17979 .isIgnored = false,
17980 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
17981 .numberOfConsumers = 1,
17982 .scale = 0.0f,
17983 .type = TestOperandType::INT32,
17984 .zeroPoint = 0
17985 }},
17986 .operations = {{
17987 .inputs = {4, 5, 6},
17988 .outputs = {0},
17989 .type = TestOperationType::ADD
17990 }, {
17991 .inputs = {0, 1, 2},
17992 .outputs = {3},
17993 .type = TestOperationType::SOFTMAX
17994 }},
17995 .outputIndexes = {3}
17996 },
17997 .minSupportedVersion = TestHalVersion::V1_2,
17998 .referenced = {}
17999 };
18000 return model;
18001 }
18002
18003 const auto dummy_test_model_axis_dim4_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_dim4_axis2_neg_all_inputs_as_internal_2());
18004
18005 } // namespace generated_tests::softmax_v1_2
18006
18007 namespace generated_tests::softmax_v1_2 {
18008
get_test_model_axis_dim4_axis3_2()18009 const TestModel& get_test_model_axis_dim4_axis3_2() {
18010 static TestModel model = {
18011 .expectFailure = false,
18012 .expectedMultinomialDistributionTolerance = 0,
18013 .isRelaxed = false,
18014 .main = { // axis
18015 .inputIndexes = {0},
18016 .operands = {{ // op1
18017 .channelQuant = {},
18018 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
18019 .dimensions = {2, 2, 2, 5},
18020 .isIgnored = false,
18021 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18022 .numberOfConsumers = 1,
18023 .scale = 0.0f,
18024 .type = TestOperandType::TENSOR_FLOAT32,
18025 .zeroPoint = 0
18026 }, { // param3
18027 .channelQuant = {},
18028 .data = TestBuffer::createFromVector<float>({1e-06f}),
18029 .dimensions = {},
18030 .isIgnored = false,
18031 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18032 .numberOfConsumers = 1,
18033 .scale = 0.0f,
18034 .type = TestOperandType::FLOAT32,
18035 .zeroPoint = 0
18036 }, { // axis
18037 .channelQuant = {},
18038 .data = TestBuffer::createFromVector<int32_t>({3}),
18039 .dimensions = {},
18040 .isIgnored = false,
18041 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18042 .numberOfConsumers = 1,
18043 .scale = 0.0f,
18044 .type = TestOperandType::INT32,
18045 .zeroPoint = 0
18046 }, { // op2
18047 .channelQuant = {},
18048 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18049 .dimensions = {2, 2, 2, 5},
18050 .isIgnored = false,
18051 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18052 .numberOfConsumers = 0,
18053 .scale = 0.0f,
18054 .type = TestOperandType::TENSOR_FLOAT32,
18055 .zeroPoint = 0
18056 }},
18057 .operations = {{
18058 .inputs = {0, 1, 2},
18059 .outputs = {3},
18060 .type = TestOperationType::SOFTMAX
18061 }},
18062 .outputIndexes = {3}
18063 },
18064 .minSupportedVersion = TestHalVersion::V1_2,
18065 .referenced = {}
18066 };
18067 return model;
18068 }
18069
18070 const auto dummy_test_model_axis_dim4_axis3_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3_2", get_test_model_axis_dim4_axis3_2());
18071
18072 } // namespace generated_tests::softmax_v1_2
18073
18074 namespace generated_tests::softmax_v1_2 {
18075
get_test_model_axis_dim4_axis3_all_inputs_as_internal_2()18076 const TestModel& get_test_model_axis_dim4_axis3_all_inputs_as_internal_2() {
18077 static TestModel model = {
18078 .expectFailure = false,
18079 .expectedMultinomialDistributionTolerance = 0,
18080 .isRelaxed = false,
18081 .main = { // axis
18082 .inputIndexes = {4},
18083 .operands = {{ // op1
18084 .channelQuant = {},
18085 .data = TestBuffer::createFromVector<float>({}),
18086 .dimensions = {2, 2, 2, 5},
18087 .isIgnored = false,
18088 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
18089 .numberOfConsumers = 1,
18090 .scale = 0.0f,
18091 .type = TestOperandType::TENSOR_FLOAT32,
18092 .zeroPoint = 0
18093 }, { // param3
18094 .channelQuant = {},
18095 .data = TestBuffer::createFromVector<float>({1e-06f}),
18096 .dimensions = {},
18097 .isIgnored = false,
18098 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18099 .numberOfConsumers = 1,
18100 .scale = 0.0f,
18101 .type = TestOperandType::FLOAT32,
18102 .zeroPoint = 0
18103 }, { // axis
18104 .channelQuant = {},
18105 .data = TestBuffer::createFromVector<int32_t>({3}),
18106 .dimensions = {},
18107 .isIgnored = false,
18108 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18109 .numberOfConsumers = 1,
18110 .scale = 0.0f,
18111 .type = TestOperandType::INT32,
18112 .zeroPoint = 0
18113 }, { // op2
18114 .channelQuant = {},
18115 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18116 .dimensions = {2, 2, 2, 5},
18117 .isIgnored = false,
18118 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18119 .numberOfConsumers = 0,
18120 .scale = 0.0f,
18121 .type = TestOperandType::TENSOR_FLOAT32,
18122 .zeroPoint = 0
18123 }, { // op1_new
18124 .channelQuant = {},
18125 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
18126 .dimensions = {2, 2, 2, 5},
18127 .isIgnored = false,
18128 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18129 .numberOfConsumers = 1,
18130 .scale = 0.0f,
18131 .type = TestOperandType::TENSOR_FLOAT32,
18132 .zeroPoint = 0
18133 }, { // placeholder110
18134 .channelQuant = {},
18135 .data = TestBuffer::createFromVector<float>({0.0f}),
18136 .dimensions = {1},
18137 .isIgnored = false,
18138 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18139 .numberOfConsumers = 1,
18140 .scale = 0.0f,
18141 .type = TestOperandType::TENSOR_FLOAT32,
18142 .zeroPoint = 0
18143 }, { // param128
18144 .channelQuant = {},
18145 .data = TestBuffer::createFromVector<int32_t>({0}),
18146 .dimensions = {},
18147 .isIgnored = false,
18148 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18149 .numberOfConsumers = 1,
18150 .scale = 0.0f,
18151 .type = TestOperandType::INT32,
18152 .zeroPoint = 0
18153 }},
18154 .operations = {{
18155 .inputs = {4, 5, 6},
18156 .outputs = {0},
18157 .type = TestOperationType::ADD
18158 }, {
18159 .inputs = {0, 1, 2},
18160 .outputs = {3},
18161 .type = TestOperationType::SOFTMAX
18162 }},
18163 .outputIndexes = {3}
18164 },
18165 .minSupportedVersion = TestHalVersion::V1_2,
18166 .referenced = {}
18167 };
18168 return model;
18169 }
18170
18171 const auto dummy_test_model_axis_dim4_axis3_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3_all_inputs_as_internal_2", get_test_model_axis_dim4_axis3_all_inputs_as_internal_2());
18172
18173 } // namespace generated_tests::softmax_v1_2
18174
18175 namespace generated_tests::softmax_v1_2 {
18176
get_test_model_axis_dim4_axis3_neg_2()18177 const TestModel& get_test_model_axis_dim4_axis3_neg_2() {
18178 static TestModel model = {
18179 .expectFailure = false,
18180 .expectedMultinomialDistributionTolerance = 0,
18181 .isRelaxed = false,
18182 .main = { // axis
18183 .inputIndexes = {0},
18184 .operands = {{ // op1
18185 .channelQuant = {},
18186 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
18187 .dimensions = {2, 2, 2, 5},
18188 .isIgnored = false,
18189 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18190 .numberOfConsumers = 1,
18191 .scale = 0.0f,
18192 .type = TestOperandType::TENSOR_FLOAT32,
18193 .zeroPoint = 0
18194 }, { // param3
18195 .channelQuant = {},
18196 .data = TestBuffer::createFromVector<float>({1e-06f}),
18197 .dimensions = {},
18198 .isIgnored = false,
18199 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18200 .numberOfConsumers = 1,
18201 .scale = 0.0f,
18202 .type = TestOperandType::FLOAT32,
18203 .zeroPoint = 0
18204 }, { // axis
18205 .channelQuant = {},
18206 .data = TestBuffer::createFromVector<int32_t>({-1}),
18207 .dimensions = {},
18208 .isIgnored = false,
18209 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18210 .numberOfConsumers = 1,
18211 .scale = 0.0f,
18212 .type = TestOperandType::INT32,
18213 .zeroPoint = 0
18214 }, { // op2
18215 .channelQuant = {},
18216 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18217 .dimensions = {2, 2, 2, 5},
18218 .isIgnored = false,
18219 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18220 .numberOfConsumers = 0,
18221 .scale = 0.0f,
18222 .type = TestOperandType::TENSOR_FLOAT32,
18223 .zeroPoint = 0
18224 }},
18225 .operations = {{
18226 .inputs = {0, 1, 2},
18227 .outputs = {3},
18228 .type = TestOperationType::SOFTMAX
18229 }},
18230 .outputIndexes = {3}
18231 },
18232 .minSupportedVersion = TestHalVersion::V1_0,
18233 .referenced = {}
18234 };
18235 return model;
18236 }
18237
18238 const auto dummy_test_model_axis_dim4_axis3_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3_neg_2", get_test_model_axis_dim4_axis3_neg_2());
18239
18240 } // namespace generated_tests::softmax_v1_2
18241
18242 namespace generated_tests::softmax_v1_2 {
18243
get_test_model_axis_dim4_axis3_neg_all_inputs_as_internal_2()18244 const TestModel& get_test_model_axis_dim4_axis3_neg_all_inputs_as_internal_2() {
18245 static TestModel model = {
18246 .expectFailure = false,
18247 .expectedMultinomialDistributionTolerance = 0,
18248 .isRelaxed = false,
18249 .main = { // axis
18250 .inputIndexes = {4},
18251 .operands = {{ // op1
18252 .channelQuant = {},
18253 .data = TestBuffer::createFromVector<float>({}),
18254 .dimensions = {2, 2, 2, 5},
18255 .isIgnored = false,
18256 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
18257 .numberOfConsumers = 1,
18258 .scale = 0.0f,
18259 .type = TestOperandType::TENSOR_FLOAT32,
18260 .zeroPoint = 0
18261 }, { // param3
18262 .channelQuant = {},
18263 .data = TestBuffer::createFromVector<float>({1e-06f}),
18264 .dimensions = {},
18265 .isIgnored = false,
18266 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18267 .numberOfConsumers = 1,
18268 .scale = 0.0f,
18269 .type = TestOperandType::FLOAT32,
18270 .zeroPoint = 0
18271 }, { // axis
18272 .channelQuant = {},
18273 .data = TestBuffer::createFromVector<int32_t>({-1}),
18274 .dimensions = {},
18275 .isIgnored = false,
18276 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18277 .numberOfConsumers = 1,
18278 .scale = 0.0f,
18279 .type = TestOperandType::INT32,
18280 .zeroPoint = 0
18281 }, { // op2
18282 .channelQuant = {},
18283 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18284 .dimensions = {2, 2, 2, 5},
18285 .isIgnored = false,
18286 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18287 .numberOfConsumers = 0,
18288 .scale = 0.0f,
18289 .type = TestOperandType::TENSOR_FLOAT32,
18290 .zeroPoint = 0
18291 }, { // op1_new
18292 .channelQuant = {},
18293 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
18294 .dimensions = {2, 2, 2, 5},
18295 .isIgnored = false,
18296 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18297 .numberOfConsumers = 1,
18298 .scale = 0.0f,
18299 .type = TestOperandType::TENSOR_FLOAT32,
18300 .zeroPoint = 0
18301 }, { // placeholder111
18302 .channelQuant = {},
18303 .data = TestBuffer::createFromVector<float>({0.0f}),
18304 .dimensions = {1},
18305 .isIgnored = false,
18306 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18307 .numberOfConsumers = 1,
18308 .scale = 0.0f,
18309 .type = TestOperandType::TENSOR_FLOAT32,
18310 .zeroPoint = 0
18311 }, { // param129
18312 .channelQuant = {},
18313 .data = TestBuffer::createFromVector<int32_t>({0}),
18314 .dimensions = {},
18315 .isIgnored = false,
18316 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18317 .numberOfConsumers = 1,
18318 .scale = 0.0f,
18319 .type = TestOperandType::INT32,
18320 .zeroPoint = 0
18321 }},
18322 .operations = {{
18323 .inputs = {4, 5, 6},
18324 .outputs = {0},
18325 .type = TestOperationType::ADD
18326 }, {
18327 .inputs = {0, 1, 2},
18328 .outputs = {3},
18329 .type = TestOperationType::SOFTMAX
18330 }},
18331 .outputIndexes = {3}
18332 },
18333 .minSupportedVersion = TestHalVersion::V1_0,
18334 .referenced = {}
18335 };
18336 return model;
18337 }
18338
18339 const auto dummy_test_model_axis_dim4_axis3_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim4_axis3_neg_all_inputs_as_internal_2", get_test_model_axis_dim4_axis3_neg_all_inputs_as_internal_2());
18340
18341 } // namespace generated_tests::softmax_v1_2
18342
18343 namespace generated_tests::softmax_v1_2 {
18344
get_test_model_axis_dim3_axis0_2()18345 const TestModel& get_test_model_axis_dim3_axis0_2() {
18346 static TestModel model = {
18347 .expectFailure = false,
18348 .expectedMultinomialDistributionTolerance = 0,
18349 .isRelaxed = false,
18350 .main = { // axis
18351 .inputIndexes = {0},
18352 .operands = {{ // op1
18353 .channelQuant = {},
18354 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
18355 .dimensions = {5, 2, 2},
18356 .isIgnored = false,
18357 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18358 .numberOfConsumers = 1,
18359 .scale = 0.0f,
18360 .type = TestOperandType::TENSOR_FLOAT32,
18361 .zeroPoint = 0
18362 }, { // param3
18363 .channelQuant = {},
18364 .data = TestBuffer::createFromVector<float>({1e-06f}),
18365 .dimensions = {},
18366 .isIgnored = false,
18367 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18368 .numberOfConsumers = 1,
18369 .scale = 0.0f,
18370 .type = TestOperandType::FLOAT32,
18371 .zeroPoint = 0
18372 }, { // axis
18373 .channelQuant = {},
18374 .data = TestBuffer::createFromVector<int32_t>({0}),
18375 .dimensions = {},
18376 .isIgnored = false,
18377 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18378 .numberOfConsumers = 1,
18379 .scale = 0.0f,
18380 .type = TestOperandType::INT32,
18381 .zeroPoint = 0
18382 }, { // op2
18383 .channelQuant = {},
18384 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18385 .dimensions = {5, 2, 2},
18386 .isIgnored = false,
18387 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18388 .numberOfConsumers = 0,
18389 .scale = 0.0f,
18390 .type = TestOperandType::TENSOR_FLOAT32,
18391 .zeroPoint = 0
18392 }},
18393 .operations = {{
18394 .inputs = {0, 1, 2},
18395 .outputs = {3},
18396 .type = TestOperationType::SOFTMAX
18397 }},
18398 .outputIndexes = {3}
18399 },
18400 .minSupportedVersion = TestHalVersion::V1_2,
18401 .referenced = {}
18402 };
18403 return model;
18404 }
18405
18406 const auto dummy_test_model_axis_dim3_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0_2", get_test_model_axis_dim3_axis0_2());
18407
18408 } // namespace generated_tests::softmax_v1_2
18409
18410 namespace generated_tests::softmax_v1_2 {
18411
get_test_model_axis_dim3_axis0_all_inputs_as_internal_2()18412 const TestModel& get_test_model_axis_dim3_axis0_all_inputs_as_internal_2() {
18413 static TestModel model = {
18414 .expectFailure = false,
18415 .expectedMultinomialDistributionTolerance = 0,
18416 .isRelaxed = false,
18417 .main = { // axis
18418 .inputIndexes = {4},
18419 .operands = {{ // op1
18420 .channelQuant = {},
18421 .data = TestBuffer::createFromVector<float>({}),
18422 .dimensions = {5, 2, 2},
18423 .isIgnored = false,
18424 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
18425 .numberOfConsumers = 1,
18426 .scale = 0.0f,
18427 .type = TestOperandType::TENSOR_FLOAT32,
18428 .zeroPoint = 0
18429 }, { // param3
18430 .channelQuant = {},
18431 .data = TestBuffer::createFromVector<float>({1e-06f}),
18432 .dimensions = {},
18433 .isIgnored = false,
18434 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18435 .numberOfConsumers = 1,
18436 .scale = 0.0f,
18437 .type = TestOperandType::FLOAT32,
18438 .zeroPoint = 0
18439 }, { // axis
18440 .channelQuant = {},
18441 .data = TestBuffer::createFromVector<int32_t>({0}),
18442 .dimensions = {},
18443 .isIgnored = false,
18444 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18445 .numberOfConsumers = 1,
18446 .scale = 0.0f,
18447 .type = TestOperandType::INT32,
18448 .zeroPoint = 0
18449 }, { // op2
18450 .channelQuant = {},
18451 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18452 .dimensions = {5, 2, 2},
18453 .isIgnored = false,
18454 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18455 .numberOfConsumers = 0,
18456 .scale = 0.0f,
18457 .type = TestOperandType::TENSOR_FLOAT32,
18458 .zeroPoint = 0
18459 }, { // op1_new
18460 .channelQuant = {},
18461 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
18462 .dimensions = {5, 2, 2},
18463 .isIgnored = false,
18464 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18465 .numberOfConsumers = 1,
18466 .scale = 0.0f,
18467 .type = TestOperandType::TENSOR_FLOAT32,
18468 .zeroPoint = 0
18469 }, { // placeholder112
18470 .channelQuant = {},
18471 .data = TestBuffer::createFromVector<float>({0.0f}),
18472 .dimensions = {1},
18473 .isIgnored = false,
18474 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18475 .numberOfConsumers = 1,
18476 .scale = 0.0f,
18477 .type = TestOperandType::TENSOR_FLOAT32,
18478 .zeroPoint = 0
18479 }, { // param130
18480 .channelQuant = {},
18481 .data = TestBuffer::createFromVector<int32_t>({0}),
18482 .dimensions = {},
18483 .isIgnored = false,
18484 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18485 .numberOfConsumers = 1,
18486 .scale = 0.0f,
18487 .type = TestOperandType::INT32,
18488 .zeroPoint = 0
18489 }},
18490 .operations = {{
18491 .inputs = {4, 5, 6},
18492 .outputs = {0},
18493 .type = TestOperationType::ADD
18494 }, {
18495 .inputs = {0, 1, 2},
18496 .outputs = {3},
18497 .type = TestOperationType::SOFTMAX
18498 }},
18499 .outputIndexes = {3}
18500 },
18501 .minSupportedVersion = TestHalVersion::V1_2,
18502 .referenced = {}
18503 };
18504 return model;
18505 }
18506
18507 const auto dummy_test_model_axis_dim3_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0_all_inputs_as_internal_2", get_test_model_axis_dim3_axis0_all_inputs_as_internal_2());
18508
18509 } // namespace generated_tests::softmax_v1_2
18510
18511 namespace generated_tests::softmax_v1_2 {
18512
get_test_model_axis_dim3_axis0_neg_2()18513 const TestModel& get_test_model_axis_dim3_axis0_neg_2() {
18514 static TestModel model = {
18515 .expectFailure = false,
18516 .expectedMultinomialDistributionTolerance = 0,
18517 .isRelaxed = false,
18518 .main = { // axis
18519 .inputIndexes = {0},
18520 .operands = {{ // op1
18521 .channelQuant = {},
18522 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
18523 .dimensions = {5, 2, 2},
18524 .isIgnored = false,
18525 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18526 .numberOfConsumers = 1,
18527 .scale = 0.0f,
18528 .type = TestOperandType::TENSOR_FLOAT32,
18529 .zeroPoint = 0
18530 }, { // param3
18531 .channelQuant = {},
18532 .data = TestBuffer::createFromVector<float>({1e-06f}),
18533 .dimensions = {},
18534 .isIgnored = false,
18535 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18536 .numberOfConsumers = 1,
18537 .scale = 0.0f,
18538 .type = TestOperandType::FLOAT32,
18539 .zeroPoint = 0
18540 }, { // axis
18541 .channelQuant = {},
18542 .data = TestBuffer::createFromVector<int32_t>({-3}),
18543 .dimensions = {},
18544 .isIgnored = false,
18545 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18546 .numberOfConsumers = 1,
18547 .scale = 0.0f,
18548 .type = TestOperandType::INT32,
18549 .zeroPoint = 0
18550 }, { // op2
18551 .channelQuant = {},
18552 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18553 .dimensions = {5, 2, 2},
18554 .isIgnored = false,
18555 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18556 .numberOfConsumers = 0,
18557 .scale = 0.0f,
18558 .type = TestOperandType::TENSOR_FLOAT32,
18559 .zeroPoint = 0
18560 }},
18561 .operations = {{
18562 .inputs = {0, 1, 2},
18563 .outputs = {3},
18564 .type = TestOperationType::SOFTMAX
18565 }},
18566 .outputIndexes = {3}
18567 },
18568 .minSupportedVersion = TestHalVersion::V1_2,
18569 .referenced = {}
18570 };
18571 return model;
18572 }
18573
18574 const auto dummy_test_model_axis_dim3_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0_neg_2", get_test_model_axis_dim3_axis0_neg_2());
18575
18576 } // namespace generated_tests::softmax_v1_2
18577
18578 namespace generated_tests::softmax_v1_2 {
18579
get_test_model_axis_dim3_axis0_neg_all_inputs_as_internal_2()18580 const TestModel& get_test_model_axis_dim3_axis0_neg_all_inputs_as_internal_2() {
18581 static TestModel model = {
18582 .expectFailure = false,
18583 .expectedMultinomialDistributionTolerance = 0,
18584 .isRelaxed = false,
18585 .main = { // axis
18586 .inputIndexes = {4},
18587 .operands = {{ // op1
18588 .channelQuant = {},
18589 .data = TestBuffer::createFromVector<float>({}),
18590 .dimensions = {5, 2, 2},
18591 .isIgnored = false,
18592 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
18593 .numberOfConsumers = 1,
18594 .scale = 0.0f,
18595 .type = TestOperandType::TENSOR_FLOAT32,
18596 .zeroPoint = 0
18597 }, { // param3
18598 .channelQuant = {},
18599 .data = TestBuffer::createFromVector<float>({1e-06f}),
18600 .dimensions = {},
18601 .isIgnored = false,
18602 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18603 .numberOfConsumers = 1,
18604 .scale = 0.0f,
18605 .type = TestOperandType::FLOAT32,
18606 .zeroPoint = 0
18607 }, { // axis
18608 .channelQuant = {},
18609 .data = TestBuffer::createFromVector<int32_t>({-3}),
18610 .dimensions = {},
18611 .isIgnored = false,
18612 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18613 .numberOfConsumers = 1,
18614 .scale = 0.0f,
18615 .type = TestOperandType::INT32,
18616 .zeroPoint = 0
18617 }, { // op2
18618 .channelQuant = {},
18619 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18620 .dimensions = {5, 2, 2},
18621 .isIgnored = false,
18622 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18623 .numberOfConsumers = 0,
18624 .scale = 0.0f,
18625 .type = TestOperandType::TENSOR_FLOAT32,
18626 .zeroPoint = 0
18627 }, { // op1_new
18628 .channelQuant = {},
18629 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
18630 .dimensions = {5, 2, 2},
18631 .isIgnored = false,
18632 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18633 .numberOfConsumers = 1,
18634 .scale = 0.0f,
18635 .type = TestOperandType::TENSOR_FLOAT32,
18636 .zeroPoint = 0
18637 }, { // placeholder113
18638 .channelQuant = {},
18639 .data = TestBuffer::createFromVector<float>({0.0f}),
18640 .dimensions = {1},
18641 .isIgnored = false,
18642 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18643 .numberOfConsumers = 1,
18644 .scale = 0.0f,
18645 .type = TestOperandType::TENSOR_FLOAT32,
18646 .zeroPoint = 0
18647 }, { // param131
18648 .channelQuant = {},
18649 .data = TestBuffer::createFromVector<int32_t>({0}),
18650 .dimensions = {},
18651 .isIgnored = false,
18652 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18653 .numberOfConsumers = 1,
18654 .scale = 0.0f,
18655 .type = TestOperandType::INT32,
18656 .zeroPoint = 0
18657 }},
18658 .operations = {{
18659 .inputs = {4, 5, 6},
18660 .outputs = {0},
18661 .type = TestOperationType::ADD
18662 }, {
18663 .inputs = {0, 1, 2},
18664 .outputs = {3},
18665 .type = TestOperationType::SOFTMAX
18666 }},
18667 .outputIndexes = {3}
18668 },
18669 .minSupportedVersion = TestHalVersion::V1_2,
18670 .referenced = {}
18671 };
18672 return model;
18673 }
18674
18675 const auto dummy_test_model_axis_dim3_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_dim3_axis0_neg_all_inputs_as_internal_2());
18676
18677 } // namespace generated_tests::softmax_v1_2
18678
18679 namespace generated_tests::softmax_v1_2 {
18680
get_test_model_axis_dim3_axis1_2()18681 const TestModel& get_test_model_axis_dim3_axis1_2() {
18682 static TestModel model = {
18683 .expectFailure = false,
18684 .expectedMultinomialDistributionTolerance = 0,
18685 .isRelaxed = false,
18686 .main = { // axis
18687 .inputIndexes = {0},
18688 .operands = {{ // op1
18689 .channelQuant = {},
18690 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
18691 .dimensions = {2, 5, 2},
18692 .isIgnored = false,
18693 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18694 .numberOfConsumers = 1,
18695 .scale = 0.0f,
18696 .type = TestOperandType::TENSOR_FLOAT32,
18697 .zeroPoint = 0
18698 }, { // param3
18699 .channelQuant = {},
18700 .data = TestBuffer::createFromVector<float>({1e-06f}),
18701 .dimensions = {},
18702 .isIgnored = false,
18703 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18704 .numberOfConsumers = 1,
18705 .scale = 0.0f,
18706 .type = TestOperandType::FLOAT32,
18707 .zeroPoint = 0
18708 }, { // axis
18709 .channelQuant = {},
18710 .data = TestBuffer::createFromVector<int32_t>({1}),
18711 .dimensions = {},
18712 .isIgnored = false,
18713 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18714 .numberOfConsumers = 1,
18715 .scale = 0.0f,
18716 .type = TestOperandType::INT32,
18717 .zeroPoint = 0
18718 }, { // op2
18719 .channelQuant = {},
18720 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18721 .dimensions = {2, 5, 2},
18722 .isIgnored = false,
18723 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18724 .numberOfConsumers = 0,
18725 .scale = 0.0f,
18726 .type = TestOperandType::TENSOR_FLOAT32,
18727 .zeroPoint = 0
18728 }},
18729 .operations = {{
18730 .inputs = {0, 1, 2},
18731 .outputs = {3},
18732 .type = TestOperationType::SOFTMAX
18733 }},
18734 .outputIndexes = {3}
18735 },
18736 .minSupportedVersion = TestHalVersion::V1_2,
18737 .referenced = {}
18738 };
18739 return model;
18740 }
18741
18742 const auto dummy_test_model_axis_dim3_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1_2", get_test_model_axis_dim3_axis1_2());
18743
18744 } // namespace generated_tests::softmax_v1_2
18745
18746 namespace generated_tests::softmax_v1_2 {
18747
get_test_model_axis_dim3_axis1_all_inputs_as_internal_2()18748 const TestModel& get_test_model_axis_dim3_axis1_all_inputs_as_internal_2() {
18749 static TestModel model = {
18750 .expectFailure = false,
18751 .expectedMultinomialDistributionTolerance = 0,
18752 .isRelaxed = false,
18753 .main = { // axis
18754 .inputIndexes = {4},
18755 .operands = {{ // op1
18756 .channelQuant = {},
18757 .data = TestBuffer::createFromVector<float>({}),
18758 .dimensions = {2, 5, 2},
18759 .isIgnored = false,
18760 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
18761 .numberOfConsumers = 1,
18762 .scale = 0.0f,
18763 .type = TestOperandType::TENSOR_FLOAT32,
18764 .zeroPoint = 0
18765 }, { // param3
18766 .channelQuant = {},
18767 .data = TestBuffer::createFromVector<float>({1e-06f}),
18768 .dimensions = {},
18769 .isIgnored = false,
18770 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18771 .numberOfConsumers = 1,
18772 .scale = 0.0f,
18773 .type = TestOperandType::FLOAT32,
18774 .zeroPoint = 0
18775 }, { // axis
18776 .channelQuant = {},
18777 .data = TestBuffer::createFromVector<int32_t>({1}),
18778 .dimensions = {},
18779 .isIgnored = false,
18780 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18781 .numberOfConsumers = 1,
18782 .scale = 0.0f,
18783 .type = TestOperandType::INT32,
18784 .zeroPoint = 0
18785 }, { // op2
18786 .channelQuant = {},
18787 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18788 .dimensions = {2, 5, 2},
18789 .isIgnored = false,
18790 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18791 .numberOfConsumers = 0,
18792 .scale = 0.0f,
18793 .type = TestOperandType::TENSOR_FLOAT32,
18794 .zeroPoint = 0
18795 }, { // op1_new
18796 .channelQuant = {},
18797 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
18798 .dimensions = {2, 5, 2},
18799 .isIgnored = false,
18800 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18801 .numberOfConsumers = 1,
18802 .scale = 0.0f,
18803 .type = TestOperandType::TENSOR_FLOAT32,
18804 .zeroPoint = 0
18805 }, { // placeholder114
18806 .channelQuant = {},
18807 .data = TestBuffer::createFromVector<float>({0.0f}),
18808 .dimensions = {1},
18809 .isIgnored = false,
18810 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18811 .numberOfConsumers = 1,
18812 .scale = 0.0f,
18813 .type = TestOperandType::TENSOR_FLOAT32,
18814 .zeroPoint = 0
18815 }, { // param132
18816 .channelQuant = {},
18817 .data = TestBuffer::createFromVector<int32_t>({0}),
18818 .dimensions = {},
18819 .isIgnored = false,
18820 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18821 .numberOfConsumers = 1,
18822 .scale = 0.0f,
18823 .type = TestOperandType::INT32,
18824 .zeroPoint = 0
18825 }},
18826 .operations = {{
18827 .inputs = {4, 5, 6},
18828 .outputs = {0},
18829 .type = TestOperationType::ADD
18830 }, {
18831 .inputs = {0, 1, 2},
18832 .outputs = {3},
18833 .type = TestOperationType::SOFTMAX
18834 }},
18835 .outputIndexes = {3}
18836 },
18837 .minSupportedVersion = TestHalVersion::V1_2,
18838 .referenced = {}
18839 };
18840 return model;
18841 }
18842
18843 const auto dummy_test_model_axis_dim3_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1_all_inputs_as_internal_2", get_test_model_axis_dim3_axis1_all_inputs_as_internal_2());
18844
18845 } // namespace generated_tests::softmax_v1_2
18846
18847 namespace generated_tests::softmax_v1_2 {
18848
get_test_model_axis_dim3_axis1_neg_2()18849 const TestModel& get_test_model_axis_dim3_axis1_neg_2() {
18850 static TestModel model = {
18851 .expectFailure = false,
18852 .expectedMultinomialDistributionTolerance = 0,
18853 .isRelaxed = false,
18854 .main = { // axis
18855 .inputIndexes = {0},
18856 .operands = {{ // op1
18857 .channelQuant = {},
18858 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
18859 .dimensions = {2, 5, 2},
18860 .isIgnored = false,
18861 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18862 .numberOfConsumers = 1,
18863 .scale = 0.0f,
18864 .type = TestOperandType::TENSOR_FLOAT32,
18865 .zeroPoint = 0
18866 }, { // param3
18867 .channelQuant = {},
18868 .data = TestBuffer::createFromVector<float>({1e-06f}),
18869 .dimensions = {},
18870 .isIgnored = false,
18871 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18872 .numberOfConsumers = 1,
18873 .scale = 0.0f,
18874 .type = TestOperandType::FLOAT32,
18875 .zeroPoint = 0
18876 }, { // axis
18877 .channelQuant = {},
18878 .data = TestBuffer::createFromVector<int32_t>({-2}),
18879 .dimensions = {},
18880 .isIgnored = false,
18881 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18882 .numberOfConsumers = 1,
18883 .scale = 0.0f,
18884 .type = TestOperandType::INT32,
18885 .zeroPoint = 0
18886 }, { // op2
18887 .channelQuant = {},
18888 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18889 .dimensions = {2, 5, 2},
18890 .isIgnored = false,
18891 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18892 .numberOfConsumers = 0,
18893 .scale = 0.0f,
18894 .type = TestOperandType::TENSOR_FLOAT32,
18895 .zeroPoint = 0
18896 }},
18897 .operations = {{
18898 .inputs = {0, 1, 2},
18899 .outputs = {3},
18900 .type = TestOperationType::SOFTMAX
18901 }},
18902 .outputIndexes = {3}
18903 },
18904 .minSupportedVersion = TestHalVersion::V1_2,
18905 .referenced = {}
18906 };
18907 return model;
18908 }
18909
18910 const auto dummy_test_model_axis_dim3_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1_neg_2", get_test_model_axis_dim3_axis1_neg_2());
18911
18912 } // namespace generated_tests::softmax_v1_2
18913
18914 namespace generated_tests::softmax_v1_2 {
18915
get_test_model_axis_dim3_axis1_neg_all_inputs_as_internal_2()18916 const TestModel& get_test_model_axis_dim3_axis1_neg_all_inputs_as_internal_2() {
18917 static TestModel model = {
18918 .expectFailure = false,
18919 .expectedMultinomialDistributionTolerance = 0,
18920 .isRelaxed = false,
18921 .main = { // axis
18922 .inputIndexes = {4},
18923 .operands = {{ // op1
18924 .channelQuant = {},
18925 .data = TestBuffer::createFromVector<float>({}),
18926 .dimensions = {2, 5, 2},
18927 .isIgnored = false,
18928 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
18929 .numberOfConsumers = 1,
18930 .scale = 0.0f,
18931 .type = TestOperandType::TENSOR_FLOAT32,
18932 .zeroPoint = 0
18933 }, { // param3
18934 .channelQuant = {},
18935 .data = TestBuffer::createFromVector<float>({1e-06f}),
18936 .dimensions = {},
18937 .isIgnored = false,
18938 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18939 .numberOfConsumers = 1,
18940 .scale = 0.0f,
18941 .type = TestOperandType::FLOAT32,
18942 .zeroPoint = 0
18943 }, { // axis
18944 .channelQuant = {},
18945 .data = TestBuffer::createFromVector<int32_t>({-2}),
18946 .dimensions = {},
18947 .isIgnored = false,
18948 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18949 .numberOfConsumers = 1,
18950 .scale = 0.0f,
18951 .type = TestOperandType::INT32,
18952 .zeroPoint = 0
18953 }, { // op2
18954 .channelQuant = {},
18955 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
18956 .dimensions = {2, 5, 2},
18957 .isIgnored = false,
18958 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
18959 .numberOfConsumers = 0,
18960 .scale = 0.0f,
18961 .type = TestOperandType::TENSOR_FLOAT32,
18962 .zeroPoint = 0
18963 }, { // op1_new
18964 .channelQuant = {},
18965 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
18966 .dimensions = {2, 5, 2},
18967 .isIgnored = false,
18968 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
18969 .numberOfConsumers = 1,
18970 .scale = 0.0f,
18971 .type = TestOperandType::TENSOR_FLOAT32,
18972 .zeroPoint = 0
18973 }, { // placeholder115
18974 .channelQuant = {},
18975 .data = TestBuffer::createFromVector<float>({0.0f}),
18976 .dimensions = {1},
18977 .isIgnored = false,
18978 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18979 .numberOfConsumers = 1,
18980 .scale = 0.0f,
18981 .type = TestOperandType::TENSOR_FLOAT32,
18982 .zeroPoint = 0
18983 }, { // param133
18984 .channelQuant = {},
18985 .data = TestBuffer::createFromVector<int32_t>({0}),
18986 .dimensions = {},
18987 .isIgnored = false,
18988 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
18989 .numberOfConsumers = 1,
18990 .scale = 0.0f,
18991 .type = TestOperandType::INT32,
18992 .zeroPoint = 0
18993 }},
18994 .operations = {{
18995 .inputs = {4, 5, 6},
18996 .outputs = {0},
18997 .type = TestOperationType::ADD
18998 }, {
18999 .inputs = {0, 1, 2},
19000 .outputs = {3},
19001 .type = TestOperationType::SOFTMAX
19002 }},
19003 .outputIndexes = {3}
19004 },
19005 .minSupportedVersion = TestHalVersion::V1_2,
19006 .referenced = {}
19007 };
19008 return model;
19009 }
19010
19011 const auto dummy_test_model_axis_dim3_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_dim3_axis1_neg_all_inputs_as_internal_2());
19012
19013 } // namespace generated_tests::softmax_v1_2
19014
19015 namespace generated_tests::softmax_v1_2 {
19016
get_test_model_axis_dim3_axis2_2()19017 const TestModel& get_test_model_axis_dim3_axis2_2() {
19018 static TestModel model = {
19019 .expectFailure = false,
19020 .expectedMultinomialDistributionTolerance = 0,
19021 .isRelaxed = false,
19022 .main = { // axis
19023 .inputIndexes = {0},
19024 .operands = {{ // op1
19025 .channelQuant = {},
19026 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19027 .dimensions = {2, 2, 5},
19028 .isIgnored = false,
19029 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19030 .numberOfConsumers = 1,
19031 .scale = 0.0f,
19032 .type = TestOperandType::TENSOR_FLOAT32,
19033 .zeroPoint = 0
19034 }, { // param3
19035 .channelQuant = {},
19036 .data = TestBuffer::createFromVector<float>({1e-06f}),
19037 .dimensions = {},
19038 .isIgnored = false,
19039 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19040 .numberOfConsumers = 1,
19041 .scale = 0.0f,
19042 .type = TestOperandType::FLOAT32,
19043 .zeroPoint = 0
19044 }, { // axis
19045 .channelQuant = {},
19046 .data = TestBuffer::createFromVector<int32_t>({2}),
19047 .dimensions = {},
19048 .isIgnored = false,
19049 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19050 .numberOfConsumers = 1,
19051 .scale = 0.0f,
19052 .type = TestOperandType::INT32,
19053 .zeroPoint = 0
19054 }, { // op2
19055 .channelQuant = {},
19056 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19057 .dimensions = {2, 2, 5},
19058 .isIgnored = false,
19059 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19060 .numberOfConsumers = 0,
19061 .scale = 0.0f,
19062 .type = TestOperandType::TENSOR_FLOAT32,
19063 .zeroPoint = 0
19064 }},
19065 .operations = {{
19066 .inputs = {0, 1, 2},
19067 .outputs = {3},
19068 .type = TestOperationType::SOFTMAX
19069 }},
19070 .outputIndexes = {3}
19071 },
19072 .minSupportedVersion = TestHalVersion::V1_2,
19073 .referenced = {}
19074 };
19075 return model;
19076 }
19077
19078 const auto dummy_test_model_axis_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2_2", get_test_model_axis_dim3_axis2_2());
19079
19080 } // namespace generated_tests::softmax_v1_2
19081
19082 namespace generated_tests::softmax_v1_2 {
19083
get_test_model_axis_dim3_axis2_all_inputs_as_internal_2()19084 const TestModel& get_test_model_axis_dim3_axis2_all_inputs_as_internal_2() {
19085 static TestModel model = {
19086 .expectFailure = false,
19087 .expectedMultinomialDistributionTolerance = 0,
19088 .isRelaxed = false,
19089 .main = { // axis
19090 .inputIndexes = {4},
19091 .operands = {{ // op1
19092 .channelQuant = {},
19093 .data = TestBuffer::createFromVector<float>({}),
19094 .dimensions = {2, 2, 5},
19095 .isIgnored = false,
19096 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
19097 .numberOfConsumers = 1,
19098 .scale = 0.0f,
19099 .type = TestOperandType::TENSOR_FLOAT32,
19100 .zeroPoint = 0
19101 }, { // param3
19102 .channelQuant = {},
19103 .data = TestBuffer::createFromVector<float>({1e-06f}),
19104 .dimensions = {},
19105 .isIgnored = false,
19106 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19107 .numberOfConsumers = 1,
19108 .scale = 0.0f,
19109 .type = TestOperandType::FLOAT32,
19110 .zeroPoint = 0
19111 }, { // axis
19112 .channelQuant = {},
19113 .data = TestBuffer::createFromVector<int32_t>({2}),
19114 .dimensions = {},
19115 .isIgnored = false,
19116 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19117 .numberOfConsumers = 1,
19118 .scale = 0.0f,
19119 .type = TestOperandType::INT32,
19120 .zeroPoint = 0
19121 }, { // op2
19122 .channelQuant = {},
19123 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19124 .dimensions = {2, 2, 5},
19125 .isIgnored = false,
19126 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19127 .numberOfConsumers = 0,
19128 .scale = 0.0f,
19129 .type = TestOperandType::TENSOR_FLOAT32,
19130 .zeroPoint = 0
19131 }, { // op1_new
19132 .channelQuant = {},
19133 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19134 .dimensions = {2, 2, 5},
19135 .isIgnored = false,
19136 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19137 .numberOfConsumers = 1,
19138 .scale = 0.0f,
19139 .type = TestOperandType::TENSOR_FLOAT32,
19140 .zeroPoint = 0
19141 }, { // placeholder116
19142 .channelQuant = {},
19143 .data = TestBuffer::createFromVector<float>({0.0f}),
19144 .dimensions = {1},
19145 .isIgnored = false,
19146 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19147 .numberOfConsumers = 1,
19148 .scale = 0.0f,
19149 .type = TestOperandType::TENSOR_FLOAT32,
19150 .zeroPoint = 0
19151 }, { // param134
19152 .channelQuant = {},
19153 .data = TestBuffer::createFromVector<int32_t>({0}),
19154 .dimensions = {},
19155 .isIgnored = false,
19156 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19157 .numberOfConsumers = 1,
19158 .scale = 0.0f,
19159 .type = TestOperandType::INT32,
19160 .zeroPoint = 0
19161 }},
19162 .operations = {{
19163 .inputs = {4, 5, 6},
19164 .outputs = {0},
19165 .type = TestOperationType::ADD
19166 }, {
19167 .inputs = {0, 1, 2},
19168 .outputs = {3},
19169 .type = TestOperationType::SOFTMAX
19170 }},
19171 .outputIndexes = {3}
19172 },
19173 .minSupportedVersion = TestHalVersion::V1_2,
19174 .referenced = {}
19175 };
19176 return model;
19177 }
19178
19179 const auto dummy_test_model_axis_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2_all_inputs_as_internal_2", get_test_model_axis_dim3_axis2_all_inputs_as_internal_2());
19180
19181 } // namespace generated_tests::softmax_v1_2
19182
19183 namespace generated_tests::softmax_v1_2 {
19184
get_test_model_axis_dim3_axis2_neg_2()19185 const TestModel& get_test_model_axis_dim3_axis2_neg_2() {
19186 static TestModel model = {
19187 .expectFailure = false,
19188 .expectedMultinomialDistributionTolerance = 0,
19189 .isRelaxed = false,
19190 .main = { // axis
19191 .inputIndexes = {0},
19192 .operands = {{ // op1
19193 .channelQuant = {},
19194 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19195 .dimensions = {2, 2, 5},
19196 .isIgnored = false,
19197 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19198 .numberOfConsumers = 1,
19199 .scale = 0.0f,
19200 .type = TestOperandType::TENSOR_FLOAT32,
19201 .zeroPoint = 0
19202 }, { // param3
19203 .channelQuant = {},
19204 .data = TestBuffer::createFromVector<float>({1e-06f}),
19205 .dimensions = {},
19206 .isIgnored = false,
19207 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19208 .numberOfConsumers = 1,
19209 .scale = 0.0f,
19210 .type = TestOperandType::FLOAT32,
19211 .zeroPoint = 0
19212 }, { // axis
19213 .channelQuant = {},
19214 .data = TestBuffer::createFromVector<int32_t>({-1}),
19215 .dimensions = {},
19216 .isIgnored = false,
19217 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19218 .numberOfConsumers = 1,
19219 .scale = 0.0f,
19220 .type = TestOperandType::INT32,
19221 .zeroPoint = 0
19222 }, { // op2
19223 .channelQuant = {},
19224 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19225 .dimensions = {2, 2, 5},
19226 .isIgnored = false,
19227 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19228 .numberOfConsumers = 0,
19229 .scale = 0.0f,
19230 .type = TestOperandType::TENSOR_FLOAT32,
19231 .zeroPoint = 0
19232 }},
19233 .operations = {{
19234 .inputs = {0, 1, 2},
19235 .outputs = {3},
19236 .type = TestOperationType::SOFTMAX
19237 }},
19238 .outputIndexes = {3}
19239 },
19240 .minSupportedVersion = TestHalVersion::V1_2,
19241 .referenced = {}
19242 };
19243 return model;
19244 }
19245
19246 const auto dummy_test_model_axis_dim3_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2_neg_2", get_test_model_axis_dim3_axis2_neg_2());
19247
19248 } // namespace generated_tests::softmax_v1_2
19249
19250 namespace generated_tests::softmax_v1_2 {
19251
get_test_model_axis_dim3_axis2_neg_all_inputs_as_internal_2()19252 const TestModel& get_test_model_axis_dim3_axis2_neg_all_inputs_as_internal_2() {
19253 static TestModel model = {
19254 .expectFailure = false,
19255 .expectedMultinomialDistributionTolerance = 0,
19256 .isRelaxed = false,
19257 .main = { // axis
19258 .inputIndexes = {4},
19259 .operands = {{ // op1
19260 .channelQuant = {},
19261 .data = TestBuffer::createFromVector<float>({}),
19262 .dimensions = {2, 2, 5},
19263 .isIgnored = false,
19264 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
19265 .numberOfConsumers = 1,
19266 .scale = 0.0f,
19267 .type = TestOperandType::TENSOR_FLOAT32,
19268 .zeroPoint = 0
19269 }, { // param3
19270 .channelQuant = {},
19271 .data = TestBuffer::createFromVector<float>({1e-06f}),
19272 .dimensions = {},
19273 .isIgnored = false,
19274 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19275 .numberOfConsumers = 1,
19276 .scale = 0.0f,
19277 .type = TestOperandType::FLOAT32,
19278 .zeroPoint = 0
19279 }, { // axis
19280 .channelQuant = {},
19281 .data = TestBuffer::createFromVector<int32_t>({-1}),
19282 .dimensions = {},
19283 .isIgnored = false,
19284 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19285 .numberOfConsumers = 1,
19286 .scale = 0.0f,
19287 .type = TestOperandType::INT32,
19288 .zeroPoint = 0
19289 }, { // op2
19290 .channelQuant = {},
19291 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19292 .dimensions = {2, 2, 5},
19293 .isIgnored = false,
19294 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19295 .numberOfConsumers = 0,
19296 .scale = 0.0f,
19297 .type = TestOperandType::TENSOR_FLOAT32,
19298 .zeroPoint = 0
19299 }, { // op1_new
19300 .channelQuant = {},
19301 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19302 .dimensions = {2, 2, 5},
19303 .isIgnored = false,
19304 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19305 .numberOfConsumers = 1,
19306 .scale = 0.0f,
19307 .type = TestOperandType::TENSOR_FLOAT32,
19308 .zeroPoint = 0
19309 }, { // placeholder117
19310 .channelQuant = {},
19311 .data = TestBuffer::createFromVector<float>({0.0f}),
19312 .dimensions = {1},
19313 .isIgnored = false,
19314 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19315 .numberOfConsumers = 1,
19316 .scale = 0.0f,
19317 .type = TestOperandType::TENSOR_FLOAT32,
19318 .zeroPoint = 0
19319 }, { // param135
19320 .channelQuant = {},
19321 .data = TestBuffer::createFromVector<int32_t>({0}),
19322 .dimensions = {},
19323 .isIgnored = false,
19324 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19325 .numberOfConsumers = 1,
19326 .scale = 0.0f,
19327 .type = TestOperandType::INT32,
19328 .zeroPoint = 0
19329 }},
19330 .operations = {{
19331 .inputs = {4, 5, 6},
19332 .outputs = {0},
19333 .type = TestOperationType::ADD
19334 }, {
19335 .inputs = {0, 1, 2},
19336 .outputs = {3},
19337 .type = TestOperationType::SOFTMAX
19338 }},
19339 .outputIndexes = {3}
19340 },
19341 .minSupportedVersion = TestHalVersion::V1_2,
19342 .referenced = {}
19343 };
19344 return model;
19345 }
19346
19347 const auto dummy_test_model_axis_dim3_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim3_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_dim3_axis2_neg_all_inputs_as_internal_2());
19348
19349 } // namespace generated_tests::softmax_v1_2
19350
19351 namespace generated_tests::softmax_v1_2 {
19352
get_test_model_axis_dim2_axis0_2()19353 const TestModel& get_test_model_axis_dim2_axis0_2() {
19354 static TestModel model = {
19355 .expectFailure = false,
19356 .expectedMultinomialDistributionTolerance = 0,
19357 .isRelaxed = false,
19358 .main = { // axis
19359 .inputIndexes = {0},
19360 .operands = {{ // op1
19361 .channelQuant = {},
19362 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
19363 .dimensions = {5, 2},
19364 .isIgnored = false,
19365 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19366 .numberOfConsumers = 1,
19367 .scale = 0.0f,
19368 .type = TestOperandType::TENSOR_FLOAT32,
19369 .zeroPoint = 0
19370 }, { // param3
19371 .channelQuant = {},
19372 .data = TestBuffer::createFromVector<float>({1e-06f}),
19373 .dimensions = {},
19374 .isIgnored = false,
19375 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19376 .numberOfConsumers = 1,
19377 .scale = 0.0f,
19378 .type = TestOperandType::FLOAT32,
19379 .zeroPoint = 0
19380 }, { // axis
19381 .channelQuant = {},
19382 .data = TestBuffer::createFromVector<int32_t>({0}),
19383 .dimensions = {},
19384 .isIgnored = false,
19385 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19386 .numberOfConsumers = 1,
19387 .scale = 0.0f,
19388 .type = TestOperandType::INT32,
19389 .zeroPoint = 0
19390 }, { // op2
19391 .channelQuant = {},
19392 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19393 .dimensions = {5, 2},
19394 .isIgnored = false,
19395 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19396 .numberOfConsumers = 0,
19397 .scale = 0.0f,
19398 .type = TestOperandType::TENSOR_FLOAT32,
19399 .zeroPoint = 0
19400 }},
19401 .operations = {{
19402 .inputs = {0, 1, 2},
19403 .outputs = {3},
19404 .type = TestOperationType::SOFTMAX
19405 }},
19406 .outputIndexes = {3}
19407 },
19408 .minSupportedVersion = TestHalVersion::V1_2,
19409 .referenced = {}
19410 };
19411 return model;
19412 }
19413
19414 const auto dummy_test_model_axis_dim2_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0_2", get_test_model_axis_dim2_axis0_2());
19415
19416 } // namespace generated_tests::softmax_v1_2
19417
19418 namespace generated_tests::softmax_v1_2 {
19419
get_test_model_axis_dim2_axis0_all_inputs_as_internal_2()19420 const TestModel& get_test_model_axis_dim2_axis0_all_inputs_as_internal_2() {
19421 static TestModel model = {
19422 .expectFailure = false,
19423 .expectedMultinomialDistributionTolerance = 0,
19424 .isRelaxed = false,
19425 .main = { // axis
19426 .inputIndexes = {4},
19427 .operands = {{ // op1
19428 .channelQuant = {},
19429 .data = TestBuffer::createFromVector<float>({}),
19430 .dimensions = {5, 2},
19431 .isIgnored = false,
19432 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
19433 .numberOfConsumers = 1,
19434 .scale = 0.0f,
19435 .type = TestOperandType::TENSOR_FLOAT32,
19436 .zeroPoint = 0
19437 }, { // param3
19438 .channelQuant = {},
19439 .data = TestBuffer::createFromVector<float>({1e-06f}),
19440 .dimensions = {},
19441 .isIgnored = false,
19442 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19443 .numberOfConsumers = 1,
19444 .scale = 0.0f,
19445 .type = TestOperandType::FLOAT32,
19446 .zeroPoint = 0
19447 }, { // axis
19448 .channelQuant = {},
19449 .data = TestBuffer::createFromVector<int32_t>({0}),
19450 .dimensions = {},
19451 .isIgnored = false,
19452 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19453 .numberOfConsumers = 1,
19454 .scale = 0.0f,
19455 .type = TestOperandType::INT32,
19456 .zeroPoint = 0
19457 }, { // op2
19458 .channelQuant = {},
19459 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19460 .dimensions = {5, 2},
19461 .isIgnored = false,
19462 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19463 .numberOfConsumers = 0,
19464 .scale = 0.0f,
19465 .type = TestOperandType::TENSOR_FLOAT32,
19466 .zeroPoint = 0
19467 }, { // op1_new
19468 .channelQuant = {},
19469 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
19470 .dimensions = {5, 2},
19471 .isIgnored = false,
19472 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19473 .numberOfConsumers = 1,
19474 .scale = 0.0f,
19475 .type = TestOperandType::TENSOR_FLOAT32,
19476 .zeroPoint = 0
19477 }, { // placeholder118
19478 .channelQuant = {},
19479 .data = TestBuffer::createFromVector<float>({0.0f}),
19480 .dimensions = {1},
19481 .isIgnored = false,
19482 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19483 .numberOfConsumers = 1,
19484 .scale = 0.0f,
19485 .type = TestOperandType::TENSOR_FLOAT32,
19486 .zeroPoint = 0
19487 }, { // param136
19488 .channelQuant = {},
19489 .data = TestBuffer::createFromVector<int32_t>({0}),
19490 .dimensions = {},
19491 .isIgnored = false,
19492 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19493 .numberOfConsumers = 1,
19494 .scale = 0.0f,
19495 .type = TestOperandType::INT32,
19496 .zeroPoint = 0
19497 }},
19498 .operations = {{
19499 .inputs = {4, 5, 6},
19500 .outputs = {0},
19501 .type = TestOperationType::ADD
19502 }, {
19503 .inputs = {0, 1, 2},
19504 .outputs = {3},
19505 .type = TestOperationType::SOFTMAX
19506 }},
19507 .outputIndexes = {3}
19508 },
19509 .minSupportedVersion = TestHalVersion::V1_2,
19510 .referenced = {}
19511 };
19512 return model;
19513 }
19514
19515 const auto dummy_test_model_axis_dim2_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0_all_inputs_as_internal_2", get_test_model_axis_dim2_axis0_all_inputs_as_internal_2());
19516
19517 } // namespace generated_tests::softmax_v1_2
19518
19519 namespace generated_tests::softmax_v1_2 {
19520
get_test_model_axis_dim2_axis0_neg_2()19521 const TestModel& get_test_model_axis_dim2_axis0_neg_2() {
19522 static TestModel model = {
19523 .expectFailure = false,
19524 .expectedMultinomialDistributionTolerance = 0,
19525 .isRelaxed = false,
19526 .main = { // axis
19527 .inputIndexes = {0},
19528 .operands = {{ // op1
19529 .channelQuant = {},
19530 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
19531 .dimensions = {5, 2},
19532 .isIgnored = false,
19533 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19534 .numberOfConsumers = 1,
19535 .scale = 0.0f,
19536 .type = TestOperandType::TENSOR_FLOAT32,
19537 .zeroPoint = 0
19538 }, { // param3
19539 .channelQuant = {},
19540 .data = TestBuffer::createFromVector<float>({1e-06f}),
19541 .dimensions = {},
19542 .isIgnored = false,
19543 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19544 .numberOfConsumers = 1,
19545 .scale = 0.0f,
19546 .type = TestOperandType::FLOAT32,
19547 .zeroPoint = 0
19548 }, { // axis
19549 .channelQuant = {},
19550 .data = TestBuffer::createFromVector<int32_t>({-2}),
19551 .dimensions = {},
19552 .isIgnored = false,
19553 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19554 .numberOfConsumers = 1,
19555 .scale = 0.0f,
19556 .type = TestOperandType::INT32,
19557 .zeroPoint = 0
19558 }, { // op2
19559 .channelQuant = {},
19560 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19561 .dimensions = {5, 2},
19562 .isIgnored = false,
19563 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19564 .numberOfConsumers = 0,
19565 .scale = 0.0f,
19566 .type = TestOperandType::TENSOR_FLOAT32,
19567 .zeroPoint = 0
19568 }},
19569 .operations = {{
19570 .inputs = {0, 1, 2},
19571 .outputs = {3},
19572 .type = TestOperationType::SOFTMAX
19573 }},
19574 .outputIndexes = {3}
19575 },
19576 .minSupportedVersion = TestHalVersion::V1_2,
19577 .referenced = {}
19578 };
19579 return model;
19580 }
19581
19582 const auto dummy_test_model_axis_dim2_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0_neg_2", get_test_model_axis_dim2_axis0_neg_2());
19583
19584 } // namespace generated_tests::softmax_v1_2
19585
19586 namespace generated_tests::softmax_v1_2 {
19587
get_test_model_axis_dim2_axis0_neg_all_inputs_as_internal_2()19588 const TestModel& get_test_model_axis_dim2_axis0_neg_all_inputs_as_internal_2() {
19589 static TestModel model = {
19590 .expectFailure = false,
19591 .expectedMultinomialDistributionTolerance = 0,
19592 .isRelaxed = false,
19593 .main = { // axis
19594 .inputIndexes = {4},
19595 .operands = {{ // op1
19596 .channelQuant = {},
19597 .data = TestBuffer::createFromVector<float>({}),
19598 .dimensions = {5, 2},
19599 .isIgnored = false,
19600 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
19601 .numberOfConsumers = 1,
19602 .scale = 0.0f,
19603 .type = TestOperandType::TENSOR_FLOAT32,
19604 .zeroPoint = 0
19605 }, { // param3
19606 .channelQuant = {},
19607 .data = TestBuffer::createFromVector<float>({1e-06f}),
19608 .dimensions = {},
19609 .isIgnored = false,
19610 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19611 .numberOfConsumers = 1,
19612 .scale = 0.0f,
19613 .type = TestOperandType::FLOAT32,
19614 .zeroPoint = 0
19615 }, { // axis
19616 .channelQuant = {},
19617 .data = TestBuffer::createFromVector<int32_t>({-2}),
19618 .dimensions = {},
19619 .isIgnored = false,
19620 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19621 .numberOfConsumers = 1,
19622 .scale = 0.0f,
19623 .type = TestOperandType::INT32,
19624 .zeroPoint = 0
19625 }, { // op2
19626 .channelQuant = {},
19627 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19628 .dimensions = {5, 2},
19629 .isIgnored = false,
19630 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19631 .numberOfConsumers = 0,
19632 .scale = 0.0f,
19633 .type = TestOperandType::TENSOR_FLOAT32,
19634 .zeroPoint = 0
19635 }, { // op1_new
19636 .channelQuant = {},
19637 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
19638 .dimensions = {5, 2},
19639 .isIgnored = false,
19640 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19641 .numberOfConsumers = 1,
19642 .scale = 0.0f,
19643 .type = TestOperandType::TENSOR_FLOAT32,
19644 .zeroPoint = 0
19645 }, { // placeholder119
19646 .channelQuant = {},
19647 .data = TestBuffer::createFromVector<float>({0.0f}),
19648 .dimensions = {1},
19649 .isIgnored = false,
19650 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19651 .numberOfConsumers = 1,
19652 .scale = 0.0f,
19653 .type = TestOperandType::TENSOR_FLOAT32,
19654 .zeroPoint = 0
19655 }, { // param137
19656 .channelQuant = {},
19657 .data = TestBuffer::createFromVector<int32_t>({0}),
19658 .dimensions = {},
19659 .isIgnored = false,
19660 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19661 .numberOfConsumers = 1,
19662 .scale = 0.0f,
19663 .type = TestOperandType::INT32,
19664 .zeroPoint = 0
19665 }},
19666 .operations = {{
19667 .inputs = {4, 5, 6},
19668 .outputs = {0},
19669 .type = TestOperationType::ADD
19670 }, {
19671 .inputs = {0, 1, 2},
19672 .outputs = {3},
19673 .type = TestOperationType::SOFTMAX
19674 }},
19675 .outputIndexes = {3}
19676 },
19677 .minSupportedVersion = TestHalVersion::V1_2,
19678 .referenced = {}
19679 };
19680 return model;
19681 }
19682
19683 const auto dummy_test_model_axis_dim2_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_dim2_axis0_neg_all_inputs_as_internal_2());
19684
19685 } // namespace generated_tests::softmax_v1_2
19686
19687 namespace generated_tests::softmax_v1_2 {
19688
get_test_model_axis_dim2_axis1_2()19689 const TestModel& get_test_model_axis_dim2_axis1_2() {
19690 static TestModel model = {
19691 .expectFailure = false,
19692 .expectedMultinomialDistributionTolerance = 0,
19693 .isRelaxed = false,
19694 .main = { // axis
19695 .inputIndexes = {0},
19696 .operands = {{ // op1
19697 .channelQuant = {},
19698 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19699 .dimensions = {2, 5},
19700 .isIgnored = false,
19701 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19702 .numberOfConsumers = 1,
19703 .scale = 0.0f,
19704 .type = TestOperandType::TENSOR_FLOAT32,
19705 .zeroPoint = 0
19706 }, { // param3
19707 .channelQuant = {},
19708 .data = TestBuffer::createFromVector<float>({1e-06f}),
19709 .dimensions = {},
19710 .isIgnored = false,
19711 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19712 .numberOfConsumers = 1,
19713 .scale = 0.0f,
19714 .type = TestOperandType::FLOAT32,
19715 .zeroPoint = 0
19716 }, { // axis
19717 .channelQuant = {},
19718 .data = TestBuffer::createFromVector<int32_t>({1}),
19719 .dimensions = {},
19720 .isIgnored = false,
19721 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19722 .numberOfConsumers = 1,
19723 .scale = 0.0f,
19724 .type = TestOperandType::INT32,
19725 .zeroPoint = 0
19726 }, { // op2
19727 .channelQuant = {},
19728 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19729 .dimensions = {2, 5},
19730 .isIgnored = false,
19731 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19732 .numberOfConsumers = 0,
19733 .scale = 0.0f,
19734 .type = TestOperandType::TENSOR_FLOAT32,
19735 .zeroPoint = 0
19736 }},
19737 .operations = {{
19738 .inputs = {0, 1, 2},
19739 .outputs = {3},
19740 .type = TestOperationType::SOFTMAX
19741 }},
19742 .outputIndexes = {3}
19743 },
19744 .minSupportedVersion = TestHalVersion::V1_2,
19745 .referenced = {}
19746 };
19747 return model;
19748 }
19749
19750 const auto dummy_test_model_axis_dim2_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1_2", get_test_model_axis_dim2_axis1_2());
19751
19752 } // namespace generated_tests::softmax_v1_2
19753
19754 namespace generated_tests::softmax_v1_2 {
19755
get_test_model_axis_dim2_axis1_all_inputs_as_internal_2()19756 const TestModel& get_test_model_axis_dim2_axis1_all_inputs_as_internal_2() {
19757 static TestModel model = {
19758 .expectFailure = false,
19759 .expectedMultinomialDistributionTolerance = 0,
19760 .isRelaxed = false,
19761 .main = { // axis
19762 .inputIndexes = {4},
19763 .operands = {{ // op1
19764 .channelQuant = {},
19765 .data = TestBuffer::createFromVector<float>({}),
19766 .dimensions = {2, 5},
19767 .isIgnored = false,
19768 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
19769 .numberOfConsumers = 1,
19770 .scale = 0.0f,
19771 .type = TestOperandType::TENSOR_FLOAT32,
19772 .zeroPoint = 0
19773 }, { // param3
19774 .channelQuant = {},
19775 .data = TestBuffer::createFromVector<float>({1e-06f}),
19776 .dimensions = {},
19777 .isIgnored = false,
19778 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19779 .numberOfConsumers = 1,
19780 .scale = 0.0f,
19781 .type = TestOperandType::FLOAT32,
19782 .zeroPoint = 0
19783 }, { // axis
19784 .channelQuant = {},
19785 .data = TestBuffer::createFromVector<int32_t>({1}),
19786 .dimensions = {},
19787 .isIgnored = false,
19788 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19789 .numberOfConsumers = 1,
19790 .scale = 0.0f,
19791 .type = TestOperandType::INT32,
19792 .zeroPoint = 0
19793 }, { // op2
19794 .channelQuant = {},
19795 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19796 .dimensions = {2, 5},
19797 .isIgnored = false,
19798 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19799 .numberOfConsumers = 0,
19800 .scale = 0.0f,
19801 .type = TestOperandType::TENSOR_FLOAT32,
19802 .zeroPoint = 0
19803 }, { // op1_new
19804 .channelQuant = {},
19805 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19806 .dimensions = {2, 5},
19807 .isIgnored = false,
19808 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19809 .numberOfConsumers = 1,
19810 .scale = 0.0f,
19811 .type = TestOperandType::TENSOR_FLOAT32,
19812 .zeroPoint = 0
19813 }, { // placeholder120
19814 .channelQuant = {},
19815 .data = TestBuffer::createFromVector<float>({0.0f}),
19816 .dimensions = {1},
19817 .isIgnored = false,
19818 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19819 .numberOfConsumers = 1,
19820 .scale = 0.0f,
19821 .type = TestOperandType::TENSOR_FLOAT32,
19822 .zeroPoint = 0
19823 }, { // param138
19824 .channelQuant = {},
19825 .data = TestBuffer::createFromVector<int32_t>({0}),
19826 .dimensions = {},
19827 .isIgnored = false,
19828 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19829 .numberOfConsumers = 1,
19830 .scale = 0.0f,
19831 .type = TestOperandType::INT32,
19832 .zeroPoint = 0
19833 }},
19834 .operations = {{
19835 .inputs = {4, 5, 6},
19836 .outputs = {0},
19837 .type = TestOperationType::ADD
19838 }, {
19839 .inputs = {0, 1, 2},
19840 .outputs = {3},
19841 .type = TestOperationType::SOFTMAX
19842 }},
19843 .outputIndexes = {3}
19844 },
19845 .minSupportedVersion = TestHalVersion::V1_2,
19846 .referenced = {}
19847 };
19848 return model;
19849 }
19850
19851 const auto dummy_test_model_axis_dim2_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1_all_inputs_as_internal_2", get_test_model_axis_dim2_axis1_all_inputs_as_internal_2());
19852
19853 } // namespace generated_tests::softmax_v1_2
19854
19855 namespace generated_tests::softmax_v1_2 {
19856
get_test_model_axis_dim2_axis1_neg_2()19857 const TestModel& get_test_model_axis_dim2_axis1_neg_2() {
19858 static TestModel model = {
19859 .expectFailure = false,
19860 .expectedMultinomialDistributionTolerance = 0,
19861 .isRelaxed = false,
19862 .main = { // axis
19863 .inputIndexes = {0},
19864 .operands = {{ // op1
19865 .channelQuant = {},
19866 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19867 .dimensions = {2, 5},
19868 .isIgnored = false,
19869 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19870 .numberOfConsumers = 1,
19871 .scale = 0.0f,
19872 .type = TestOperandType::TENSOR_FLOAT32,
19873 .zeroPoint = 0
19874 }, { // param3
19875 .channelQuant = {},
19876 .data = TestBuffer::createFromVector<float>({1e-06f}),
19877 .dimensions = {},
19878 .isIgnored = false,
19879 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19880 .numberOfConsumers = 1,
19881 .scale = 0.0f,
19882 .type = TestOperandType::FLOAT32,
19883 .zeroPoint = 0
19884 }, { // axis
19885 .channelQuant = {},
19886 .data = TestBuffer::createFromVector<int32_t>({-1}),
19887 .dimensions = {},
19888 .isIgnored = false,
19889 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19890 .numberOfConsumers = 1,
19891 .scale = 0.0f,
19892 .type = TestOperandType::INT32,
19893 .zeroPoint = 0
19894 }, { // op2
19895 .channelQuant = {},
19896 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19897 .dimensions = {2, 5},
19898 .isIgnored = false,
19899 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19900 .numberOfConsumers = 0,
19901 .scale = 0.0f,
19902 .type = TestOperandType::TENSOR_FLOAT32,
19903 .zeroPoint = 0
19904 }},
19905 .operations = {{
19906 .inputs = {0, 1, 2},
19907 .outputs = {3},
19908 .type = TestOperationType::SOFTMAX
19909 }},
19910 .outputIndexes = {3}
19911 },
19912 .minSupportedVersion = TestHalVersion::V1_0,
19913 .referenced = {}
19914 };
19915 return model;
19916 }
19917
19918 const auto dummy_test_model_axis_dim2_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1_neg_2", get_test_model_axis_dim2_axis1_neg_2());
19919
19920 } // namespace generated_tests::softmax_v1_2
19921
19922 namespace generated_tests::softmax_v1_2 {
19923
get_test_model_axis_dim2_axis1_neg_all_inputs_as_internal_2()19924 const TestModel& get_test_model_axis_dim2_axis1_neg_all_inputs_as_internal_2() {
19925 static TestModel model = {
19926 .expectFailure = false,
19927 .expectedMultinomialDistributionTolerance = 0,
19928 .isRelaxed = false,
19929 .main = { // axis
19930 .inputIndexes = {4},
19931 .operands = {{ // op1
19932 .channelQuant = {},
19933 .data = TestBuffer::createFromVector<float>({}),
19934 .dimensions = {2, 5},
19935 .isIgnored = false,
19936 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
19937 .numberOfConsumers = 1,
19938 .scale = 0.0f,
19939 .type = TestOperandType::TENSOR_FLOAT32,
19940 .zeroPoint = 0
19941 }, { // param3
19942 .channelQuant = {},
19943 .data = TestBuffer::createFromVector<float>({1e-06f}),
19944 .dimensions = {},
19945 .isIgnored = false,
19946 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19947 .numberOfConsumers = 1,
19948 .scale = 0.0f,
19949 .type = TestOperandType::FLOAT32,
19950 .zeroPoint = 0
19951 }, { // axis
19952 .channelQuant = {},
19953 .data = TestBuffer::createFromVector<int32_t>({-1}),
19954 .dimensions = {},
19955 .isIgnored = false,
19956 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19957 .numberOfConsumers = 1,
19958 .scale = 0.0f,
19959 .type = TestOperandType::INT32,
19960 .zeroPoint = 0
19961 }, { // op2
19962 .channelQuant = {},
19963 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
19964 .dimensions = {2, 5},
19965 .isIgnored = false,
19966 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
19967 .numberOfConsumers = 0,
19968 .scale = 0.0f,
19969 .type = TestOperandType::TENSOR_FLOAT32,
19970 .zeroPoint = 0
19971 }, { // op1_new
19972 .channelQuant = {},
19973 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
19974 .dimensions = {2, 5},
19975 .isIgnored = false,
19976 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19977 .numberOfConsumers = 1,
19978 .scale = 0.0f,
19979 .type = TestOperandType::TENSOR_FLOAT32,
19980 .zeroPoint = 0
19981 }, { // placeholder121
19982 .channelQuant = {},
19983 .data = TestBuffer::createFromVector<float>({0.0f}),
19984 .dimensions = {1},
19985 .isIgnored = false,
19986 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19987 .numberOfConsumers = 1,
19988 .scale = 0.0f,
19989 .type = TestOperandType::TENSOR_FLOAT32,
19990 .zeroPoint = 0
19991 }, { // param139
19992 .channelQuant = {},
19993 .data = TestBuffer::createFromVector<int32_t>({0}),
19994 .dimensions = {},
19995 .isIgnored = false,
19996 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19997 .numberOfConsumers = 1,
19998 .scale = 0.0f,
19999 .type = TestOperandType::INT32,
20000 .zeroPoint = 0
20001 }},
20002 .operations = {{
20003 .inputs = {4, 5, 6},
20004 .outputs = {0},
20005 .type = TestOperationType::ADD
20006 }, {
20007 .inputs = {0, 1, 2},
20008 .outputs = {3},
20009 .type = TestOperationType::SOFTMAX
20010 }},
20011 .outputIndexes = {3}
20012 },
20013 .minSupportedVersion = TestHalVersion::V1_0,
20014 .referenced = {}
20015 };
20016 return model;
20017 }
20018
20019 const auto dummy_test_model_axis_dim2_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim2_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_dim2_axis1_neg_all_inputs_as_internal_2());
20020
20021 } // namespace generated_tests::softmax_v1_2
20022
20023 namespace generated_tests::softmax_v1_2 {
20024
get_test_model_axis_dim1_axis0_2()20025 const TestModel& get_test_model_axis_dim1_axis0_2() {
20026 static TestModel model = {
20027 .expectFailure = false,
20028 .expectedMultinomialDistributionTolerance = 0,
20029 .isRelaxed = false,
20030 .main = { // axis
20031 .inputIndexes = {0},
20032 .operands = {{ // op1
20033 .channelQuant = {},
20034 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
20035 .dimensions = {5},
20036 .isIgnored = false,
20037 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20038 .numberOfConsumers = 1,
20039 .scale = 0.0f,
20040 .type = TestOperandType::TENSOR_FLOAT32,
20041 .zeroPoint = 0
20042 }, { // param3
20043 .channelQuant = {},
20044 .data = TestBuffer::createFromVector<float>({1e-06f}),
20045 .dimensions = {},
20046 .isIgnored = false,
20047 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20048 .numberOfConsumers = 1,
20049 .scale = 0.0f,
20050 .type = TestOperandType::FLOAT32,
20051 .zeroPoint = 0
20052 }, { // axis
20053 .channelQuant = {},
20054 .data = TestBuffer::createFromVector<int32_t>({0}),
20055 .dimensions = {},
20056 .isIgnored = false,
20057 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20058 .numberOfConsumers = 1,
20059 .scale = 0.0f,
20060 .type = TestOperandType::INT32,
20061 .zeroPoint = 0
20062 }, { // op2
20063 .channelQuant = {},
20064 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20065 .dimensions = {5},
20066 .isIgnored = false,
20067 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20068 .numberOfConsumers = 0,
20069 .scale = 0.0f,
20070 .type = TestOperandType::TENSOR_FLOAT32,
20071 .zeroPoint = 0
20072 }},
20073 .operations = {{
20074 .inputs = {0, 1, 2},
20075 .outputs = {3},
20076 .type = TestOperationType::SOFTMAX
20077 }},
20078 .outputIndexes = {3}
20079 },
20080 .minSupportedVersion = TestHalVersion::V1_2,
20081 .referenced = {}
20082 };
20083 return model;
20084 }
20085
20086 const auto dummy_test_model_axis_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0_2", get_test_model_axis_dim1_axis0_2());
20087
20088 } // namespace generated_tests::softmax_v1_2
20089
20090 namespace generated_tests::softmax_v1_2 {
20091
get_test_model_axis_dim1_axis0_all_inputs_as_internal_2()20092 const TestModel& get_test_model_axis_dim1_axis0_all_inputs_as_internal_2() {
20093 static TestModel model = {
20094 .expectFailure = false,
20095 .expectedMultinomialDistributionTolerance = 0,
20096 .isRelaxed = false,
20097 .main = { // axis
20098 .inputIndexes = {4},
20099 .operands = {{ // op1
20100 .channelQuant = {},
20101 .data = TestBuffer::createFromVector<float>({}),
20102 .dimensions = {5},
20103 .isIgnored = false,
20104 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
20105 .numberOfConsumers = 1,
20106 .scale = 0.0f,
20107 .type = TestOperandType::TENSOR_FLOAT32,
20108 .zeroPoint = 0
20109 }, { // param3
20110 .channelQuant = {},
20111 .data = TestBuffer::createFromVector<float>({1e-06f}),
20112 .dimensions = {},
20113 .isIgnored = false,
20114 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20115 .numberOfConsumers = 1,
20116 .scale = 0.0f,
20117 .type = TestOperandType::FLOAT32,
20118 .zeroPoint = 0
20119 }, { // axis
20120 .channelQuant = {},
20121 .data = TestBuffer::createFromVector<int32_t>({0}),
20122 .dimensions = {},
20123 .isIgnored = false,
20124 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20125 .numberOfConsumers = 1,
20126 .scale = 0.0f,
20127 .type = TestOperandType::INT32,
20128 .zeroPoint = 0
20129 }, { // op2
20130 .channelQuant = {},
20131 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20132 .dimensions = {5},
20133 .isIgnored = false,
20134 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20135 .numberOfConsumers = 0,
20136 .scale = 0.0f,
20137 .type = TestOperandType::TENSOR_FLOAT32,
20138 .zeroPoint = 0
20139 }, { // op1_new
20140 .channelQuant = {},
20141 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
20142 .dimensions = {5},
20143 .isIgnored = false,
20144 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20145 .numberOfConsumers = 1,
20146 .scale = 0.0f,
20147 .type = TestOperandType::TENSOR_FLOAT32,
20148 .zeroPoint = 0
20149 }, { // placeholder122
20150 .channelQuant = {},
20151 .data = TestBuffer::createFromVector<float>({0.0f}),
20152 .dimensions = {1},
20153 .isIgnored = false,
20154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20155 .numberOfConsumers = 1,
20156 .scale = 0.0f,
20157 .type = TestOperandType::TENSOR_FLOAT32,
20158 .zeroPoint = 0
20159 }, { // param140
20160 .channelQuant = {},
20161 .data = TestBuffer::createFromVector<int32_t>({0}),
20162 .dimensions = {},
20163 .isIgnored = false,
20164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20165 .numberOfConsumers = 1,
20166 .scale = 0.0f,
20167 .type = TestOperandType::INT32,
20168 .zeroPoint = 0
20169 }},
20170 .operations = {{
20171 .inputs = {4, 5, 6},
20172 .outputs = {0},
20173 .type = TestOperationType::ADD
20174 }, {
20175 .inputs = {0, 1, 2},
20176 .outputs = {3},
20177 .type = TestOperationType::SOFTMAX
20178 }},
20179 .outputIndexes = {3}
20180 },
20181 .minSupportedVersion = TestHalVersion::V1_2,
20182 .referenced = {}
20183 };
20184 return model;
20185 }
20186
20187 const auto dummy_test_model_axis_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0_all_inputs_as_internal_2", get_test_model_axis_dim1_axis0_all_inputs_as_internal_2());
20188
20189 } // namespace generated_tests::softmax_v1_2
20190
20191 namespace generated_tests::softmax_v1_2 {
20192
get_test_model_axis_dim1_axis0_neg_2()20193 const TestModel& get_test_model_axis_dim1_axis0_neg_2() {
20194 static TestModel model = {
20195 .expectFailure = false,
20196 .expectedMultinomialDistributionTolerance = 0,
20197 .isRelaxed = false,
20198 .main = { // axis
20199 .inputIndexes = {0},
20200 .operands = {{ // op1
20201 .channelQuant = {},
20202 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
20203 .dimensions = {5},
20204 .isIgnored = false,
20205 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20206 .numberOfConsumers = 1,
20207 .scale = 0.0f,
20208 .type = TestOperandType::TENSOR_FLOAT32,
20209 .zeroPoint = 0
20210 }, { // param3
20211 .channelQuant = {},
20212 .data = TestBuffer::createFromVector<float>({1e-06f}),
20213 .dimensions = {},
20214 .isIgnored = false,
20215 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20216 .numberOfConsumers = 1,
20217 .scale = 0.0f,
20218 .type = TestOperandType::FLOAT32,
20219 .zeroPoint = 0
20220 }, { // axis
20221 .channelQuant = {},
20222 .data = TestBuffer::createFromVector<int32_t>({-1}),
20223 .dimensions = {},
20224 .isIgnored = false,
20225 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20226 .numberOfConsumers = 1,
20227 .scale = 0.0f,
20228 .type = TestOperandType::INT32,
20229 .zeroPoint = 0
20230 }, { // op2
20231 .channelQuant = {},
20232 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20233 .dimensions = {5},
20234 .isIgnored = false,
20235 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20236 .numberOfConsumers = 0,
20237 .scale = 0.0f,
20238 .type = TestOperandType::TENSOR_FLOAT32,
20239 .zeroPoint = 0
20240 }},
20241 .operations = {{
20242 .inputs = {0, 1, 2},
20243 .outputs = {3},
20244 .type = TestOperationType::SOFTMAX
20245 }},
20246 .outputIndexes = {3}
20247 },
20248 .minSupportedVersion = TestHalVersion::V1_2,
20249 .referenced = {}
20250 };
20251 return model;
20252 }
20253
20254 const auto dummy_test_model_axis_dim1_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0_neg_2", get_test_model_axis_dim1_axis0_neg_2());
20255
20256 } // namespace generated_tests::softmax_v1_2
20257
20258 namespace generated_tests::softmax_v1_2 {
20259
get_test_model_axis_dim1_axis0_neg_all_inputs_as_internal_2()20260 const TestModel& get_test_model_axis_dim1_axis0_neg_all_inputs_as_internal_2() {
20261 static TestModel model = {
20262 .expectFailure = false,
20263 .expectedMultinomialDistributionTolerance = 0,
20264 .isRelaxed = false,
20265 .main = { // axis
20266 .inputIndexes = {4},
20267 .operands = {{ // op1
20268 .channelQuant = {},
20269 .data = TestBuffer::createFromVector<float>({}),
20270 .dimensions = {5},
20271 .isIgnored = false,
20272 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
20273 .numberOfConsumers = 1,
20274 .scale = 0.0f,
20275 .type = TestOperandType::TENSOR_FLOAT32,
20276 .zeroPoint = 0
20277 }, { // param3
20278 .channelQuant = {},
20279 .data = TestBuffer::createFromVector<float>({1e-06f}),
20280 .dimensions = {},
20281 .isIgnored = false,
20282 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20283 .numberOfConsumers = 1,
20284 .scale = 0.0f,
20285 .type = TestOperandType::FLOAT32,
20286 .zeroPoint = 0
20287 }, { // axis
20288 .channelQuant = {},
20289 .data = TestBuffer::createFromVector<int32_t>({-1}),
20290 .dimensions = {},
20291 .isIgnored = false,
20292 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20293 .numberOfConsumers = 1,
20294 .scale = 0.0f,
20295 .type = TestOperandType::INT32,
20296 .zeroPoint = 0
20297 }, { // op2
20298 .channelQuant = {},
20299 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20300 .dimensions = {5},
20301 .isIgnored = false,
20302 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20303 .numberOfConsumers = 0,
20304 .scale = 0.0f,
20305 .type = TestOperandType::TENSOR_FLOAT32,
20306 .zeroPoint = 0
20307 }, { // op1_new
20308 .channelQuant = {},
20309 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
20310 .dimensions = {5},
20311 .isIgnored = false,
20312 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20313 .numberOfConsumers = 1,
20314 .scale = 0.0f,
20315 .type = TestOperandType::TENSOR_FLOAT32,
20316 .zeroPoint = 0
20317 }, { // placeholder123
20318 .channelQuant = {},
20319 .data = TestBuffer::createFromVector<float>({0.0f}),
20320 .dimensions = {1},
20321 .isIgnored = false,
20322 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20323 .numberOfConsumers = 1,
20324 .scale = 0.0f,
20325 .type = TestOperandType::TENSOR_FLOAT32,
20326 .zeroPoint = 0
20327 }, { // param141
20328 .channelQuant = {},
20329 .data = TestBuffer::createFromVector<int32_t>({0}),
20330 .dimensions = {},
20331 .isIgnored = false,
20332 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20333 .numberOfConsumers = 1,
20334 .scale = 0.0f,
20335 .type = TestOperandType::INT32,
20336 .zeroPoint = 0
20337 }},
20338 .operations = {{
20339 .inputs = {4, 5, 6},
20340 .outputs = {0},
20341 .type = TestOperationType::ADD
20342 }, {
20343 .inputs = {0, 1, 2},
20344 .outputs = {3},
20345 .type = TestOperationType::SOFTMAX
20346 }},
20347 .outputIndexes = {3}
20348 },
20349 .minSupportedVersion = TestHalVersion::V1_2,
20350 .referenced = {}
20351 };
20352 return model;
20353 }
20354
20355 const auto dummy_test_model_axis_dim1_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_dim1_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_dim1_axis0_neg_all_inputs_as_internal_2());
20356
20357 } // namespace generated_tests::softmax_v1_2
20358
20359 namespace generated_tests::softmax_v1_2 {
20360
get_test_model_axis_relaxed_dim4_axis0_2()20361 const TestModel& get_test_model_axis_relaxed_dim4_axis0_2() {
20362 static TestModel model = {
20363 .expectFailure = false,
20364 .expectedMultinomialDistributionTolerance = 0,
20365 .isRelaxed = true,
20366 .main = { // axis
20367 .inputIndexes = {0},
20368 .operands = {{ // op1
20369 .channelQuant = {},
20370 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20371 .dimensions = {5, 2, 2, 2},
20372 .isIgnored = false,
20373 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20374 .numberOfConsumers = 1,
20375 .scale = 0.0f,
20376 .type = TestOperandType::TENSOR_FLOAT32,
20377 .zeroPoint = 0
20378 }, { // param3
20379 .channelQuant = {},
20380 .data = TestBuffer::createFromVector<float>({1e-06f}),
20381 .dimensions = {},
20382 .isIgnored = false,
20383 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20384 .numberOfConsumers = 1,
20385 .scale = 0.0f,
20386 .type = TestOperandType::FLOAT32,
20387 .zeroPoint = 0
20388 }, { // axis
20389 .channelQuant = {},
20390 .data = TestBuffer::createFromVector<int32_t>({0}),
20391 .dimensions = {},
20392 .isIgnored = false,
20393 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20394 .numberOfConsumers = 1,
20395 .scale = 0.0f,
20396 .type = TestOperandType::INT32,
20397 .zeroPoint = 0
20398 }, { // op2
20399 .channelQuant = {},
20400 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20401 .dimensions = {5, 2, 2, 2},
20402 .isIgnored = false,
20403 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20404 .numberOfConsumers = 0,
20405 .scale = 0.0f,
20406 .type = TestOperandType::TENSOR_FLOAT32,
20407 .zeroPoint = 0
20408 }},
20409 .operations = {{
20410 .inputs = {0, 1, 2},
20411 .outputs = {3},
20412 .type = TestOperationType::SOFTMAX
20413 }},
20414 .outputIndexes = {3}
20415 },
20416 .minSupportedVersion = TestHalVersion::UNKNOWN,
20417 .referenced = {}
20418 };
20419 return model;
20420 }
20421
20422 const auto dummy_test_model_axis_relaxed_dim4_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0_2", get_test_model_axis_relaxed_dim4_axis0_2());
20423
20424 } // namespace generated_tests::softmax_v1_2
20425
20426 namespace generated_tests::softmax_v1_2 {
20427
get_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal_2()20428 const TestModel& get_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal_2() {
20429 static TestModel model = {
20430 .expectFailure = false,
20431 .expectedMultinomialDistributionTolerance = 0,
20432 .isRelaxed = true,
20433 .main = { // axis
20434 .inputIndexes = {4},
20435 .operands = {{ // op1
20436 .channelQuant = {},
20437 .data = TestBuffer::createFromVector<float>({}),
20438 .dimensions = {5, 2, 2, 2},
20439 .isIgnored = false,
20440 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
20441 .numberOfConsumers = 1,
20442 .scale = 0.0f,
20443 .type = TestOperandType::TENSOR_FLOAT32,
20444 .zeroPoint = 0
20445 }, { // param3
20446 .channelQuant = {},
20447 .data = TestBuffer::createFromVector<float>({1e-06f}),
20448 .dimensions = {},
20449 .isIgnored = false,
20450 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20451 .numberOfConsumers = 1,
20452 .scale = 0.0f,
20453 .type = TestOperandType::FLOAT32,
20454 .zeroPoint = 0
20455 }, { // axis
20456 .channelQuant = {},
20457 .data = TestBuffer::createFromVector<int32_t>({0}),
20458 .dimensions = {},
20459 .isIgnored = false,
20460 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20461 .numberOfConsumers = 1,
20462 .scale = 0.0f,
20463 .type = TestOperandType::INT32,
20464 .zeroPoint = 0
20465 }, { // op2
20466 .channelQuant = {},
20467 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20468 .dimensions = {5, 2, 2, 2},
20469 .isIgnored = false,
20470 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20471 .numberOfConsumers = 0,
20472 .scale = 0.0f,
20473 .type = TestOperandType::TENSOR_FLOAT32,
20474 .zeroPoint = 0
20475 }, { // op1_new
20476 .channelQuant = {},
20477 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20478 .dimensions = {5, 2, 2, 2},
20479 .isIgnored = false,
20480 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20481 .numberOfConsumers = 1,
20482 .scale = 0.0f,
20483 .type = TestOperandType::TENSOR_FLOAT32,
20484 .zeroPoint = 0
20485 }, { // placeholder124
20486 .channelQuant = {},
20487 .data = TestBuffer::createFromVector<float>({0.0f}),
20488 .dimensions = {1},
20489 .isIgnored = false,
20490 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20491 .numberOfConsumers = 1,
20492 .scale = 0.0f,
20493 .type = TestOperandType::TENSOR_FLOAT32,
20494 .zeroPoint = 0
20495 }, { // param142
20496 .channelQuant = {},
20497 .data = TestBuffer::createFromVector<int32_t>({0}),
20498 .dimensions = {},
20499 .isIgnored = false,
20500 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20501 .numberOfConsumers = 1,
20502 .scale = 0.0f,
20503 .type = TestOperandType::INT32,
20504 .zeroPoint = 0
20505 }},
20506 .operations = {{
20507 .inputs = {4, 5, 6},
20508 .outputs = {0},
20509 .type = TestOperationType::ADD
20510 }, {
20511 .inputs = {0, 1, 2},
20512 .outputs = {3},
20513 .type = TestOperationType::SOFTMAX
20514 }},
20515 .outputIndexes = {3}
20516 },
20517 .minSupportedVersion = TestHalVersion::UNKNOWN,
20518 .referenced = {}
20519 };
20520 return model;
20521 }
20522
20523 const auto dummy_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis0_all_inputs_as_internal_2());
20524
20525 } // namespace generated_tests::softmax_v1_2
20526
20527 namespace generated_tests::softmax_v1_2 {
20528
get_test_model_axis_relaxed_dim4_axis0_neg_2()20529 const TestModel& get_test_model_axis_relaxed_dim4_axis0_neg_2() {
20530 static TestModel model = {
20531 .expectFailure = false,
20532 .expectedMultinomialDistributionTolerance = 0,
20533 .isRelaxed = true,
20534 .main = { // axis
20535 .inputIndexes = {0},
20536 .operands = {{ // op1
20537 .channelQuant = {},
20538 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20539 .dimensions = {5, 2, 2, 2},
20540 .isIgnored = false,
20541 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20542 .numberOfConsumers = 1,
20543 .scale = 0.0f,
20544 .type = TestOperandType::TENSOR_FLOAT32,
20545 .zeroPoint = 0
20546 }, { // param3
20547 .channelQuant = {},
20548 .data = TestBuffer::createFromVector<float>({1e-06f}),
20549 .dimensions = {},
20550 .isIgnored = false,
20551 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20552 .numberOfConsumers = 1,
20553 .scale = 0.0f,
20554 .type = TestOperandType::FLOAT32,
20555 .zeroPoint = 0
20556 }, { // axis
20557 .channelQuant = {},
20558 .data = TestBuffer::createFromVector<int32_t>({-4}),
20559 .dimensions = {},
20560 .isIgnored = false,
20561 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20562 .numberOfConsumers = 1,
20563 .scale = 0.0f,
20564 .type = TestOperandType::INT32,
20565 .zeroPoint = 0
20566 }, { // op2
20567 .channelQuant = {},
20568 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20569 .dimensions = {5, 2, 2, 2},
20570 .isIgnored = false,
20571 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20572 .numberOfConsumers = 0,
20573 .scale = 0.0f,
20574 .type = TestOperandType::TENSOR_FLOAT32,
20575 .zeroPoint = 0
20576 }},
20577 .operations = {{
20578 .inputs = {0, 1, 2},
20579 .outputs = {3},
20580 .type = TestOperationType::SOFTMAX
20581 }},
20582 .outputIndexes = {3}
20583 },
20584 .minSupportedVersion = TestHalVersion::UNKNOWN,
20585 .referenced = {}
20586 };
20587 return model;
20588 }
20589
20590 const auto dummy_test_model_axis_relaxed_dim4_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0_neg_2", get_test_model_axis_relaxed_dim4_axis0_neg_2());
20591
20592 } // namespace generated_tests::softmax_v1_2
20593
20594 namespace generated_tests::softmax_v1_2 {
20595
get_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal_2()20596 const TestModel& get_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal_2() {
20597 static TestModel model = {
20598 .expectFailure = false,
20599 .expectedMultinomialDistributionTolerance = 0,
20600 .isRelaxed = true,
20601 .main = { // axis
20602 .inputIndexes = {4},
20603 .operands = {{ // op1
20604 .channelQuant = {},
20605 .data = TestBuffer::createFromVector<float>({}),
20606 .dimensions = {5, 2, 2, 2},
20607 .isIgnored = false,
20608 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
20609 .numberOfConsumers = 1,
20610 .scale = 0.0f,
20611 .type = TestOperandType::TENSOR_FLOAT32,
20612 .zeroPoint = 0
20613 }, { // param3
20614 .channelQuant = {},
20615 .data = TestBuffer::createFromVector<float>({1e-06f}),
20616 .dimensions = {},
20617 .isIgnored = false,
20618 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20619 .numberOfConsumers = 1,
20620 .scale = 0.0f,
20621 .type = TestOperandType::FLOAT32,
20622 .zeroPoint = 0
20623 }, { // axis
20624 .channelQuant = {},
20625 .data = TestBuffer::createFromVector<int32_t>({-4}),
20626 .dimensions = {},
20627 .isIgnored = false,
20628 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20629 .numberOfConsumers = 1,
20630 .scale = 0.0f,
20631 .type = TestOperandType::INT32,
20632 .zeroPoint = 0
20633 }, { // op2
20634 .channelQuant = {},
20635 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20636 .dimensions = {5, 2, 2, 2},
20637 .isIgnored = false,
20638 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20639 .numberOfConsumers = 0,
20640 .scale = 0.0f,
20641 .type = TestOperandType::TENSOR_FLOAT32,
20642 .zeroPoint = 0
20643 }, { // op1_new
20644 .channelQuant = {},
20645 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20646 .dimensions = {5, 2, 2, 2},
20647 .isIgnored = false,
20648 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20649 .numberOfConsumers = 1,
20650 .scale = 0.0f,
20651 .type = TestOperandType::TENSOR_FLOAT32,
20652 .zeroPoint = 0
20653 }, { // placeholder125
20654 .channelQuant = {},
20655 .data = TestBuffer::createFromVector<float>({0.0f}),
20656 .dimensions = {1},
20657 .isIgnored = false,
20658 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20659 .numberOfConsumers = 1,
20660 .scale = 0.0f,
20661 .type = TestOperandType::TENSOR_FLOAT32,
20662 .zeroPoint = 0
20663 }, { // param143
20664 .channelQuant = {},
20665 .data = TestBuffer::createFromVector<int32_t>({0}),
20666 .dimensions = {},
20667 .isIgnored = false,
20668 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20669 .numberOfConsumers = 1,
20670 .scale = 0.0f,
20671 .type = TestOperandType::INT32,
20672 .zeroPoint = 0
20673 }},
20674 .operations = {{
20675 .inputs = {4, 5, 6},
20676 .outputs = {0},
20677 .type = TestOperationType::ADD
20678 }, {
20679 .inputs = {0, 1, 2},
20680 .outputs = {3},
20681 .type = TestOperationType::SOFTMAX
20682 }},
20683 .outputIndexes = {3}
20684 },
20685 .minSupportedVersion = TestHalVersion::UNKNOWN,
20686 .referenced = {}
20687 };
20688 return model;
20689 }
20690
20691 const auto dummy_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis0_neg_all_inputs_as_internal_2());
20692
20693 } // namespace generated_tests::softmax_v1_2
20694
20695 namespace generated_tests::softmax_v1_2 {
20696
get_test_model_axis_relaxed_dim4_axis1_2()20697 const TestModel& get_test_model_axis_relaxed_dim4_axis1_2() {
20698 static TestModel model = {
20699 .expectFailure = false,
20700 .expectedMultinomialDistributionTolerance = 0,
20701 .isRelaxed = true,
20702 .main = { // axis
20703 .inputIndexes = {0},
20704 .operands = {{ // op1
20705 .channelQuant = {},
20706 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20707 .dimensions = {2, 5, 2, 2},
20708 .isIgnored = false,
20709 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20710 .numberOfConsumers = 1,
20711 .scale = 0.0f,
20712 .type = TestOperandType::TENSOR_FLOAT32,
20713 .zeroPoint = 0
20714 }, { // param3
20715 .channelQuant = {},
20716 .data = TestBuffer::createFromVector<float>({1e-06f}),
20717 .dimensions = {},
20718 .isIgnored = false,
20719 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20720 .numberOfConsumers = 1,
20721 .scale = 0.0f,
20722 .type = TestOperandType::FLOAT32,
20723 .zeroPoint = 0
20724 }, { // axis
20725 .channelQuant = {},
20726 .data = TestBuffer::createFromVector<int32_t>({1}),
20727 .dimensions = {},
20728 .isIgnored = false,
20729 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20730 .numberOfConsumers = 1,
20731 .scale = 0.0f,
20732 .type = TestOperandType::INT32,
20733 .zeroPoint = 0
20734 }, { // op2
20735 .channelQuant = {},
20736 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20737 .dimensions = {2, 5, 2, 2},
20738 .isIgnored = false,
20739 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20740 .numberOfConsumers = 0,
20741 .scale = 0.0f,
20742 .type = TestOperandType::TENSOR_FLOAT32,
20743 .zeroPoint = 0
20744 }},
20745 .operations = {{
20746 .inputs = {0, 1, 2},
20747 .outputs = {3},
20748 .type = TestOperationType::SOFTMAX
20749 }},
20750 .outputIndexes = {3}
20751 },
20752 .minSupportedVersion = TestHalVersion::UNKNOWN,
20753 .referenced = {}
20754 };
20755 return model;
20756 }
20757
20758 const auto dummy_test_model_axis_relaxed_dim4_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1_2", get_test_model_axis_relaxed_dim4_axis1_2());
20759
20760 } // namespace generated_tests::softmax_v1_2
20761
20762 namespace generated_tests::softmax_v1_2 {
20763
get_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal_2()20764 const TestModel& get_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal_2() {
20765 static TestModel model = {
20766 .expectFailure = false,
20767 .expectedMultinomialDistributionTolerance = 0,
20768 .isRelaxed = true,
20769 .main = { // axis
20770 .inputIndexes = {4},
20771 .operands = {{ // op1
20772 .channelQuant = {},
20773 .data = TestBuffer::createFromVector<float>({}),
20774 .dimensions = {2, 5, 2, 2},
20775 .isIgnored = false,
20776 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
20777 .numberOfConsumers = 1,
20778 .scale = 0.0f,
20779 .type = TestOperandType::TENSOR_FLOAT32,
20780 .zeroPoint = 0
20781 }, { // param3
20782 .channelQuant = {},
20783 .data = TestBuffer::createFromVector<float>({1e-06f}),
20784 .dimensions = {},
20785 .isIgnored = false,
20786 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20787 .numberOfConsumers = 1,
20788 .scale = 0.0f,
20789 .type = TestOperandType::FLOAT32,
20790 .zeroPoint = 0
20791 }, { // axis
20792 .channelQuant = {},
20793 .data = TestBuffer::createFromVector<int32_t>({1}),
20794 .dimensions = {},
20795 .isIgnored = false,
20796 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20797 .numberOfConsumers = 1,
20798 .scale = 0.0f,
20799 .type = TestOperandType::INT32,
20800 .zeroPoint = 0
20801 }, { // op2
20802 .channelQuant = {},
20803 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20804 .dimensions = {2, 5, 2, 2},
20805 .isIgnored = false,
20806 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20807 .numberOfConsumers = 0,
20808 .scale = 0.0f,
20809 .type = TestOperandType::TENSOR_FLOAT32,
20810 .zeroPoint = 0
20811 }, { // op1_new
20812 .channelQuant = {},
20813 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20814 .dimensions = {2, 5, 2, 2},
20815 .isIgnored = false,
20816 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20817 .numberOfConsumers = 1,
20818 .scale = 0.0f,
20819 .type = TestOperandType::TENSOR_FLOAT32,
20820 .zeroPoint = 0
20821 }, { // placeholder126
20822 .channelQuant = {},
20823 .data = TestBuffer::createFromVector<float>({0.0f}),
20824 .dimensions = {1},
20825 .isIgnored = false,
20826 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20827 .numberOfConsumers = 1,
20828 .scale = 0.0f,
20829 .type = TestOperandType::TENSOR_FLOAT32,
20830 .zeroPoint = 0
20831 }, { // param144
20832 .channelQuant = {},
20833 .data = TestBuffer::createFromVector<int32_t>({0}),
20834 .dimensions = {},
20835 .isIgnored = false,
20836 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20837 .numberOfConsumers = 1,
20838 .scale = 0.0f,
20839 .type = TestOperandType::INT32,
20840 .zeroPoint = 0
20841 }},
20842 .operations = {{
20843 .inputs = {4, 5, 6},
20844 .outputs = {0},
20845 .type = TestOperationType::ADD
20846 }, {
20847 .inputs = {0, 1, 2},
20848 .outputs = {3},
20849 .type = TestOperationType::SOFTMAX
20850 }},
20851 .outputIndexes = {3}
20852 },
20853 .minSupportedVersion = TestHalVersion::UNKNOWN,
20854 .referenced = {}
20855 };
20856 return model;
20857 }
20858
20859 const auto dummy_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis1_all_inputs_as_internal_2());
20860
20861 } // namespace generated_tests::softmax_v1_2
20862
20863 namespace generated_tests::softmax_v1_2 {
20864
get_test_model_axis_relaxed_dim4_axis1_neg_2()20865 const TestModel& get_test_model_axis_relaxed_dim4_axis1_neg_2() {
20866 static TestModel model = {
20867 .expectFailure = false,
20868 .expectedMultinomialDistributionTolerance = 0,
20869 .isRelaxed = true,
20870 .main = { // axis
20871 .inputIndexes = {0},
20872 .operands = {{ // op1
20873 .channelQuant = {},
20874 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20875 .dimensions = {2, 5, 2, 2},
20876 .isIgnored = false,
20877 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20878 .numberOfConsumers = 1,
20879 .scale = 0.0f,
20880 .type = TestOperandType::TENSOR_FLOAT32,
20881 .zeroPoint = 0
20882 }, { // param3
20883 .channelQuant = {},
20884 .data = TestBuffer::createFromVector<float>({1e-06f}),
20885 .dimensions = {},
20886 .isIgnored = false,
20887 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20888 .numberOfConsumers = 1,
20889 .scale = 0.0f,
20890 .type = TestOperandType::FLOAT32,
20891 .zeroPoint = 0
20892 }, { // axis
20893 .channelQuant = {},
20894 .data = TestBuffer::createFromVector<int32_t>({-3}),
20895 .dimensions = {},
20896 .isIgnored = false,
20897 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20898 .numberOfConsumers = 1,
20899 .scale = 0.0f,
20900 .type = TestOperandType::INT32,
20901 .zeroPoint = 0
20902 }, { // op2
20903 .channelQuant = {},
20904 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20905 .dimensions = {2, 5, 2, 2},
20906 .isIgnored = false,
20907 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20908 .numberOfConsumers = 0,
20909 .scale = 0.0f,
20910 .type = TestOperandType::TENSOR_FLOAT32,
20911 .zeroPoint = 0
20912 }},
20913 .operations = {{
20914 .inputs = {0, 1, 2},
20915 .outputs = {3},
20916 .type = TestOperationType::SOFTMAX
20917 }},
20918 .outputIndexes = {3}
20919 },
20920 .minSupportedVersion = TestHalVersion::UNKNOWN,
20921 .referenced = {}
20922 };
20923 return model;
20924 }
20925
20926 const auto dummy_test_model_axis_relaxed_dim4_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1_neg_2", get_test_model_axis_relaxed_dim4_axis1_neg_2());
20927
20928 } // namespace generated_tests::softmax_v1_2
20929
20930 namespace generated_tests::softmax_v1_2 {
20931
get_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal_2()20932 const TestModel& get_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal_2() {
20933 static TestModel model = {
20934 .expectFailure = false,
20935 .expectedMultinomialDistributionTolerance = 0,
20936 .isRelaxed = true,
20937 .main = { // axis
20938 .inputIndexes = {4},
20939 .operands = {{ // op1
20940 .channelQuant = {},
20941 .data = TestBuffer::createFromVector<float>({}),
20942 .dimensions = {2, 5, 2, 2},
20943 .isIgnored = false,
20944 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
20945 .numberOfConsumers = 1,
20946 .scale = 0.0f,
20947 .type = TestOperandType::TENSOR_FLOAT32,
20948 .zeroPoint = 0
20949 }, { // param3
20950 .channelQuant = {},
20951 .data = TestBuffer::createFromVector<float>({1e-06f}),
20952 .dimensions = {},
20953 .isIgnored = false,
20954 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20955 .numberOfConsumers = 1,
20956 .scale = 0.0f,
20957 .type = TestOperandType::FLOAT32,
20958 .zeroPoint = 0
20959 }, { // axis
20960 .channelQuant = {},
20961 .data = TestBuffer::createFromVector<int32_t>({-3}),
20962 .dimensions = {},
20963 .isIgnored = false,
20964 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20965 .numberOfConsumers = 1,
20966 .scale = 0.0f,
20967 .type = TestOperandType::INT32,
20968 .zeroPoint = 0
20969 }, { // op2
20970 .channelQuant = {},
20971 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
20972 .dimensions = {2, 5, 2, 2},
20973 .isIgnored = false,
20974 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
20975 .numberOfConsumers = 0,
20976 .scale = 0.0f,
20977 .type = TestOperandType::TENSOR_FLOAT32,
20978 .zeroPoint = 0
20979 }, { // op1_new
20980 .channelQuant = {},
20981 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
20982 .dimensions = {2, 5, 2, 2},
20983 .isIgnored = false,
20984 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
20985 .numberOfConsumers = 1,
20986 .scale = 0.0f,
20987 .type = TestOperandType::TENSOR_FLOAT32,
20988 .zeroPoint = 0
20989 }, { // placeholder127
20990 .channelQuant = {},
20991 .data = TestBuffer::createFromVector<float>({0.0f}),
20992 .dimensions = {1},
20993 .isIgnored = false,
20994 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
20995 .numberOfConsumers = 1,
20996 .scale = 0.0f,
20997 .type = TestOperandType::TENSOR_FLOAT32,
20998 .zeroPoint = 0
20999 }, { // param145
21000 .channelQuant = {},
21001 .data = TestBuffer::createFromVector<int32_t>({0}),
21002 .dimensions = {},
21003 .isIgnored = false,
21004 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21005 .numberOfConsumers = 1,
21006 .scale = 0.0f,
21007 .type = TestOperandType::INT32,
21008 .zeroPoint = 0
21009 }},
21010 .operations = {{
21011 .inputs = {4, 5, 6},
21012 .outputs = {0},
21013 .type = TestOperationType::ADD
21014 }, {
21015 .inputs = {0, 1, 2},
21016 .outputs = {3},
21017 .type = TestOperationType::SOFTMAX
21018 }},
21019 .outputIndexes = {3}
21020 },
21021 .minSupportedVersion = TestHalVersion::UNKNOWN,
21022 .referenced = {}
21023 };
21024 return model;
21025 }
21026
21027 const auto dummy_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis1_neg_all_inputs_as_internal_2());
21028
21029 } // namespace generated_tests::softmax_v1_2
21030
21031 namespace generated_tests::softmax_v1_2 {
21032
get_test_model_axis_relaxed_dim4_axis2_2()21033 const TestModel& get_test_model_axis_relaxed_dim4_axis2_2() {
21034 static TestModel model = {
21035 .expectFailure = false,
21036 .expectedMultinomialDistributionTolerance = 0,
21037 .isRelaxed = true,
21038 .main = { // axis
21039 .inputIndexes = {0},
21040 .operands = {{ // op1
21041 .channelQuant = {},
21042 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
21043 .dimensions = {2, 2, 5, 2},
21044 .isIgnored = false,
21045 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21046 .numberOfConsumers = 1,
21047 .scale = 0.0f,
21048 .type = TestOperandType::TENSOR_FLOAT32,
21049 .zeroPoint = 0
21050 }, { // param3
21051 .channelQuant = {},
21052 .data = TestBuffer::createFromVector<float>({1e-06f}),
21053 .dimensions = {},
21054 .isIgnored = false,
21055 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21056 .numberOfConsumers = 1,
21057 .scale = 0.0f,
21058 .type = TestOperandType::FLOAT32,
21059 .zeroPoint = 0
21060 }, { // axis
21061 .channelQuant = {},
21062 .data = TestBuffer::createFromVector<int32_t>({2}),
21063 .dimensions = {},
21064 .isIgnored = false,
21065 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21066 .numberOfConsumers = 1,
21067 .scale = 0.0f,
21068 .type = TestOperandType::INT32,
21069 .zeroPoint = 0
21070 }, { // op2
21071 .channelQuant = {},
21072 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21073 .dimensions = {2, 2, 5, 2},
21074 .isIgnored = false,
21075 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21076 .numberOfConsumers = 0,
21077 .scale = 0.0f,
21078 .type = TestOperandType::TENSOR_FLOAT32,
21079 .zeroPoint = 0
21080 }},
21081 .operations = {{
21082 .inputs = {0, 1, 2},
21083 .outputs = {3},
21084 .type = TestOperationType::SOFTMAX
21085 }},
21086 .outputIndexes = {3}
21087 },
21088 .minSupportedVersion = TestHalVersion::UNKNOWN,
21089 .referenced = {}
21090 };
21091 return model;
21092 }
21093
21094 const auto dummy_test_model_axis_relaxed_dim4_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2_2", get_test_model_axis_relaxed_dim4_axis2_2());
21095
21096 } // namespace generated_tests::softmax_v1_2
21097
21098 namespace generated_tests::softmax_v1_2 {
21099
get_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal_2()21100 const TestModel& get_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal_2() {
21101 static TestModel model = {
21102 .expectFailure = false,
21103 .expectedMultinomialDistributionTolerance = 0,
21104 .isRelaxed = true,
21105 .main = { // axis
21106 .inputIndexes = {4},
21107 .operands = {{ // op1
21108 .channelQuant = {},
21109 .data = TestBuffer::createFromVector<float>({}),
21110 .dimensions = {2, 2, 5, 2},
21111 .isIgnored = false,
21112 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
21113 .numberOfConsumers = 1,
21114 .scale = 0.0f,
21115 .type = TestOperandType::TENSOR_FLOAT32,
21116 .zeroPoint = 0
21117 }, { // param3
21118 .channelQuant = {},
21119 .data = TestBuffer::createFromVector<float>({1e-06f}),
21120 .dimensions = {},
21121 .isIgnored = false,
21122 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21123 .numberOfConsumers = 1,
21124 .scale = 0.0f,
21125 .type = TestOperandType::FLOAT32,
21126 .zeroPoint = 0
21127 }, { // axis
21128 .channelQuant = {},
21129 .data = TestBuffer::createFromVector<int32_t>({2}),
21130 .dimensions = {},
21131 .isIgnored = false,
21132 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21133 .numberOfConsumers = 1,
21134 .scale = 0.0f,
21135 .type = TestOperandType::INT32,
21136 .zeroPoint = 0
21137 }, { // op2
21138 .channelQuant = {},
21139 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21140 .dimensions = {2, 2, 5, 2},
21141 .isIgnored = false,
21142 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21143 .numberOfConsumers = 0,
21144 .scale = 0.0f,
21145 .type = TestOperandType::TENSOR_FLOAT32,
21146 .zeroPoint = 0
21147 }, { // op1_new
21148 .channelQuant = {},
21149 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
21150 .dimensions = {2, 2, 5, 2},
21151 .isIgnored = false,
21152 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21153 .numberOfConsumers = 1,
21154 .scale = 0.0f,
21155 .type = TestOperandType::TENSOR_FLOAT32,
21156 .zeroPoint = 0
21157 }, { // placeholder128
21158 .channelQuant = {},
21159 .data = TestBuffer::createFromVector<float>({0.0f}),
21160 .dimensions = {1},
21161 .isIgnored = false,
21162 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21163 .numberOfConsumers = 1,
21164 .scale = 0.0f,
21165 .type = TestOperandType::TENSOR_FLOAT32,
21166 .zeroPoint = 0
21167 }, { // param146
21168 .channelQuant = {},
21169 .data = TestBuffer::createFromVector<int32_t>({0}),
21170 .dimensions = {},
21171 .isIgnored = false,
21172 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21173 .numberOfConsumers = 1,
21174 .scale = 0.0f,
21175 .type = TestOperandType::INT32,
21176 .zeroPoint = 0
21177 }},
21178 .operations = {{
21179 .inputs = {4, 5, 6},
21180 .outputs = {0},
21181 .type = TestOperationType::ADD
21182 }, {
21183 .inputs = {0, 1, 2},
21184 .outputs = {3},
21185 .type = TestOperationType::SOFTMAX
21186 }},
21187 .outputIndexes = {3}
21188 },
21189 .minSupportedVersion = TestHalVersion::UNKNOWN,
21190 .referenced = {}
21191 };
21192 return model;
21193 }
21194
21195 const auto dummy_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis2_all_inputs_as_internal_2());
21196
21197 } // namespace generated_tests::softmax_v1_2
21198
21199 namespace generated_tests::softmax_v1_2 {
21200
get_test_model_axis_relaxed_dim4_axis2_neg_2()21201 const TestModel& get_test_model_axis_relaxed_dim4_axis2_neg_2() {
21202 static TestModel model = {
21203 .expectFailure = false,
21204 .expectedMultinomialDistributionTolerance = 0,
21205 .isRelaxed = true,
21206 .main = { // axis
21207 .inputIndexes = {0},
21208 .operands = {{ // op1
21209 .channelQuant = {},
21210 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
21211 .dimensions = {2, 2, 5, 2},
21212 .isIgnored = false,
21213 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21214 .numberOfConsumers = 1,
21215 .scale = 0.0f,
21216 .type = TestOperandType::TENSOR_FLOAT32,
21217 .zeroPoint = 0
21218 }, { // param3
21219 .channelQuant = {},
21220 .data = TestBuffer::createFromVector<float>({1e-06f}),
21221 .dimensions = {},
21222 .isIgnored = false,
21223 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21224 .numberOfConsumers = 1,
21225 .scale = 0.0f,
21226 .type = TestOperandType::FLOAT32,
21227 .zeroPoint = 0
21228 }, { // axis
21229 .channelQuant = {},
21230 .data = TestBuffer::createFromVector<int32_t>({-2}),
21231 .dimensions = {},
21232 .isIgnored = false,
21233 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21234 .numberOfConsumers = 1,
21235 .scale = 0.0f,
21236 .type = TestOperandType::INT32,
21237 .zeroPoint = 0
21238 }, { // op2
21239 .channelQuant = {},
21240 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21241 .dimensions = {2, 2, 5, 2},
21242 .isIgnored = false,
21243 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21244 .numberOfConsumers = 0,
21245 .scale = 0.0f,
21246 .type = TestOperandType::TENSOR_FLOAT32,
21247 .zeroPoint = 0
21248 }},
21249 .operations = {{
21250 .inputs = {0, 1, 2},
21251 .outputs = {3},
21252 .type = TestOperationType::SOFTMAX
21253 }},
21254 .outputIndexes = {3}
21255 },
21256 .minSupportedVersion = TestHalVersion::UNKNOWN,
21257 .referenced = {}
21258 };
21259 return model;
21260 }
21261
21262 const auto dummy_test_model_axis_relaxed_dim4_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2_neg_2", get_test_model_axis_relaxed_dim4_axis2_neg_2());
21263
21264 } // namespace generated_tests::softmax_v1_2
21265
21266 namespace generated_tests::softmax_v1_2 {
21267
get_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal_2()21268 const TestModel& get_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal_2() {
21269 static TestModel model = {
21270 .expectFailure = false,
21271 .expectedMultinomialDistributionTolerance = 0,
21272 .isRelaxed = true,
21273 .main = { // axis
21274 .inputIndexes = {4},
21275 .operands = {{ // op1
21276 .channelQuant = {},
21277 .data = TestBuffer::createFromVector<float>({}),
21278 .dimensions = {2, 2, 5, 2},
21279 .isIgnored = false,
21280 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
21281 .numberOfConsumers = 1,
21282 .scale = 0.0f,
21283 .type = TestOperandType::TENSOR_FLOAT32,
21284 .zeroPoint = 0
21285 }, { // param3
21286 .channelQuant = {},
21287 .data = TestBuffer::createFromVector<float>({1e-06f}),
21288 .dimensions = {},
21289 .isIgnored = false,
21290 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21291 .numberOfConsumers = 1,
21292 .scale = 0.0f,
21293 .type = TestOperandType::FLOAT32,
21294 .zeroPoint = 0
21295 }, { // axis
21296 .channelQuant = {},
21297 .data = TestBuffer::createFromVector<int32_t>({-2}),
21298 .dimensions = {},
21299 .isIgnored = false,
21300 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21301 .numberOfConsumers = 1,
21302 .scale = 0.0f,
21303 .type = TestOperandType::INT32,
21304 .zeroPoint = 0
21305 }, { // op2
21306 .channelQuant = {},
21307 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21308 .dimensions = {2, 2, 5, 2},
21309 .isIgnored = false,
21310 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21311 .numberOfConsumers = 0,
21312 .scale = 0.0f,
21313 .type = TestOperandType::TENSOR_FLOAT32,
21314 .zeroPoint = 0
21315 }, { // op1_new
21316 .channelQuant = {},
21317 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
21318 .dimensions = {2, 2, 5, 2},
21319 .isIgnored = false,
21320 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21321 .numberOfConsumers = 1,
21322 .scale = 0.0f,
21323 .type = TestOperandType::TENSOR_FLOAT32,
21324 .zeroPoint = 0
21325 }, { // placeholder129
21326 .channelQuant = {},
21327 .data = TestBuffer::createFromVector<float>({0.0f}),
21328 .dimensions = {1},
21329 .isIgnored = false,
21330 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21331 .numberOfConsumers = 1,
21332 .scale = 0.0f,
21333 .type = TestOperandType::TENSOR_FLOAT32,
21334 .zeroPoint = 0
21335 }, { // param147
21336 .channelQuant = {},
21337 .data = TestBuffer::createFromVector<int32_t>({0}),
21338 .dimensions = {},
21339 .isIgnored = false,
21340 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21341 .numberOfConsumers = 1,
21342 .scale = 0.0f,
21343 .type = TestOperandType::INT32,
21344 .zeroPoint = 0
21345 }},
21346 .operations = {{
21347 .inputs = {4, 5, 6},
21348 .outputs = {0},
21349 .type = TestOperationType::ADD
21350 }, {
21351 .inputs = {0, 1, 2},
21352 .outputs = {3},
21353 .type = TestOperationType::SOFTMAX
21354 }},
21355 .outputIndexes = {3}
21356 },
21357 .minSupportedVersion = TestHalVersion::UNKNOWN,
21358 .referenced = {}
21359 };
21360 return model;
21361 }
21362
21363 const auto dummy_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis2_neg_all_inputs_as_internal_2());
21364
21365 } // namespace generated_tests::softmax_v1_2
21366
21367 namespace generated_tests::softmax_v1_2 {
21368
get_test_model_axis_relaxed_dim4_axis3_2()21369 const TestModel& get_test_model_axis_relaxed_dim4_axis3_2() {
21370 static TestModel model = {
21371 .expectFailure = false,
21372 .expectedMultinomialDistributionTolerance = 0,
21373 .isRelaxed = true,
21374 .main = { // axis
21375 .inputIndexes = {0},
21376 .operands = {{ // op1
21377 .channelQuant = {},
21378 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
21379 .dimensions = {2, 2, 2, 5},
21380 .isIgnored = false,
21381 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21382 .numberOfConsumers = 1,
21383 .scale = 0.0f,
21384 .type = TestOperandType::TENSOR_FLOAT32,
21385 .zeroPoint = 0
21386 }, { // param3
21387 .channelQuant = {},
21388 .data = TestBuffer::createFromVector<float>({1e-06f}),
21389 .dimensions = {},
21390 .isIgnored = false,
21391 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21392 .numberOfConsumers = 1,
21393 .scale = 0.0f,
21394 .type = TestOperandType::FLOAT32,
21395 .zeroPoint = 0
21396 }, { // axis
21397 .channelQuant = {},
21398 .data = TestBuffer::createFromVector<int32_t>({3}),
21399 .dimensions = {},
21400 .isIgnored = false,
21401 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21402 .numberOfConsumers = 1,
21403 .scale = 0.0f,
21404 .type = TestOperandType::INT32,
21405 .zeroPoint = 0
21406 }, { // op2
21407 .channelQuant = {},
21408 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21409 .dimensions = {2, 2, 2, 5},
21410 .isIgnored = false,
21411 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21412 .numberOfConsumers = 0,
21413 .scale = 0.0f,
21414 .type = TestOperandType::TENSOR_FLOAT32,
21415 .zeroPoint = 0
21416 }},
21417 .operations = {{
21418 .inputs = {0, 1, 2},
21419 .outputs = {3},
21420 .type = TestOperationType::SOFTMAX
21421 }},
21422 .outputIndexes = {3}
21423 },
21424 .minSupportedVersion = TestHalVersion::UNKNOWN,
21425 .referenced = {}
21426 };
21427 return model;
21428 }
21429
21430 const auto dummy_test_model_axis_relaxed_dim4_axis3_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3_2", get_test_model_axis_relaxed_dim4_axis3_2());
21431
21432 } // namespace generated_tests::softmax_v1_2
21433
21434 namespace generated_tests::softmax_v1_2 {
21435
get_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal_2()21436 const TestModel& get_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal_2() {
21437 static TestModel model = {
21438 .expectFailure = false,
21439 .expectedMultinomialDistributionTolerance = 0,
21440 .isRelaxed = true,
21441 .main = { // axis
21442 .inputIndexes = {4},
21443 .operands = {{ // op1
21444 .channelQuant = {},
21445 .data = TestBuffer::createFromVector<float>({}),
21446 .dimensions = {2, 2, 2, 5},
21447 .isIgnored = false,
21448 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
21449 .numberOfConsumers = 1,
21450 .scale = 0.0f,
21451 .type = TestOperandType::TENSOR_FLOAT32,
21452 .zeroPoint = 0
21453 }, { // param3
21454 .channelQuant = {},
21455 .data = TestBuffer::createFromVector<float>({1e-06f}),
21456 .dimensions = {},
21457 .isIgnored = false,
21458 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21459 .numberOfConsumers = 1,
21460 .scale = 0.0f,
21461 .type = TestOperandType::FLOAT32,
21462 .zeroPoint = 0
21463 }, { // axis
21464 .channelQuant = {},
21465 .data = TestBuffer::createFromVector<int32_t>({3}),
21466 .dimensions = {},
21467 .isIgnored = false,
21468 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21469 .numberOfConsumers = 1,
21470 .scale = 0.0f,
21471 .type = TestOperandType::INT32,
21472 .zeroPoint = 0
21473 }, { // op2
21474 .channelQuant = {},
21475 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21476 .dimensions = {2, 2, 2, 5},
21477 .isIgnored = false,
21478 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21479 .numberOfConsumers = 0,
21480 .scale = 0.0f,
21481 .type = TestOperandType::TENSOR_FLOAT32,
21482 .zeroPoint = 0
21483 }, { // op1_new
21484 .channelQuant = {},
21485 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
21486 .dimensions = {2, 2, 2, 5},
21487 .isIgnored = false,
21488 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21489 .numberOfConsumers = 1,
21490 .scale = 0.0f,
21491 .type = TestOperandType::TENSOR_FLOAT32,
21492 .zeroPoint = 0
21493 }, { // placeholder130
21494 .channelQuant = {},
21495 .data = TestBuffer::createFromVector<float>({0.0f}),
21496 .dimensions = {1},
21497 .isIgnored = false,
21498 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21499 .numberOfConsumers = 1,
21500 .scale = 0.0f,
21501 .type = TestOperandType::TENSOR_FLOAT32,
21502 .zeroPoint = 0
21503 }, { // param148
21504 .channelQuant = {},
21505 .data = TestBuffer::createFromVector<int32_t>({0}),
21506 .dimensions = {},
21507 .isIgnored = false,
21508 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21509 .numberOfConsumers = 1,
21510 .scale = 0.0f,
21511 .type = TestOperandType::INT32,
21512 .zeroPoint = 0
21513 }},
21514 .operations = {{
21515 .inputs = {4, 5, 6},
21516 .outputs = {0},
21517 .type = TestOperationType::ADD
21518 }, {
21519 .inputs = {0, 1, 2},
21520 .outputs = {3},
21521 .type = TestOperationType::SOFTMAX
21522 }},
21523 .outputIndexes = {3}
21524 },
21525 .minSupportedVersion = TestHalVersion::UNKNOWN,
21526 .referenced = {}
21527 };
21528 return model;
21529 }
21530
21531 const auto dummy_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis3_all_inputs_as_internal_2());
21532
21533 } // namespace generated_tests::softmax_v1_2
21534
21535 namespace generated_tests::softmax_v1_2 {
21536
get_test_model_axis_relaxed_dim4_axis3_neg_2()21537 const TestModel& get_test_model_axis_relaxed_dim4_axis3_neg_2() {
21538 static TestModel model = {
21539 .expectFailure = false,
21540 .expectedMultinomialDistributionTolerance = 0,
21541 .isRelaxed = true,
21542 .main = { // axis
21543 .inputIndexes = {0},
21544 .operands = {{ // op1
21545 .channelQuant = {},
21546 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
21547 .dimensions = {2, 2, 2, 5},
21548 .isIgnored = false,
21549 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21550 .numberOfConsumers = 1,
21551 .scale = 0.0f,
21552 .type = TestOperandType::TENSOR_FLOAT32,
21553 .zeroPoint = 0
21554 }, { // param3
21555 .channelQuant = {},
21556 .data = TestBuffer::createFromVector<float>({1e-06f}),
21557 .dimensions = {},
21558 .isIgnored = false,
21559 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21560 .numberOfConsumers = 1,
21561 .scale = 0.0f,
21562 .type = TestOperandType::FLOAT32,
21563 .zeroPoint = 0
21564 }, { // axis
21565 .channelQuant = {},
21566 .data = TestBuffer::createFromVector<int32_t>({-1}),
21567 .dimensions = {},
21568 .isIgnored = false,
21569 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21570 .numberOfConsumers = 1,
21571 .scale = 0.0f,
21572 .type = TestOperandType::INT32,
21573 .zeroPoint = 0
21574 }, { // op2
21575 .channelQuant = {},
21576 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21577 .dimensions = {2, 2, 2, 5},
21578 .isIgnored = false,
21579 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21580 .numberOfConsumers = 0,
21581 .scale = 0.0f,
21582 .type = TestOperandType::TENSOR_FLOAT32,
21583 .zeroPoint = 0
21584 }},
21585 .operations = {{
21586 .inputs = {0, 1, 2},
21587 .outputs = {3},
21588 .type = TestOperationType::SOFTMAX
21589 }},
21590 .outputIndexes = {3}
21591 },
21592 .minSupportedVersion = TestHalVersion::UNKNOWN,
21593 .referenced = {}
21594 };
21595 return model;
21596 }
21597
21598 const auto dummy_test_model_axis_relaxed_dim4_axis3_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3_neg_2", get_test_model_axis_relaxed_dim4_axis3_neg_2());
21599
21600 } // namespace generated_tests::softmax_v1_2
21601
21602 namespace generated_tests::softmax_v1_2 {
21603
get_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal_2()21604 const TestModel& get_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal_2() {
21605 static TestModel model = {
21606 .expectFailure = false,
21607 .expectedMultinomialDistributionTolerance = 0,
21608 .isRelaxed = true,
21609 .main = { // axis
21610 .inputIndexes = {4},
21611 .operands = {{ // op1
21612 .channelQuant = {},
21613 .data = TestBuffer::createFromVector<float>({}),
21614 .dimensions = {2, 2, 2, 5},
21615 .isIgnored = false,
21616 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
21617 .numberOfConsumers = 1,
21618 .scale = 0.0f,
21619 .type = TestOperandType::TENSOR_FLOAT32,
21620 .zeroPoint = 0
21621 }, { // param3
21622 .channelQuant = {},
21623 .data = TestBuffer::createFromVector<float>({1e-06f}),
21624 .dimensions = {},
21625 .isIgnored = false,
21626 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21627 .numberOfConsumers = 1,
21628 .scale = 0.0f,
21629 .type = TestOperandType::FLOAT32,
21630 .zeroPoint = 0
21631 }, { // axis
21632 .channelQuant = {},
21633 .data = TestBuffer::createFromVector<int32_t>({-1}),
21634 .dimensions = {},
21635 .isIgnored = false,
21636 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21637 .numberOfConsumers = 1,
21638 .scale = 0.0f,
21639 .type = TestOperandType::INT32,
21640 .zeroPoint = 0
21641 }, { // op2
21642 .channelQuant = {},
21643 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21644 .dimensions = {2, 2, 2, 5},
21645 .isIgnored = false,
21646 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21647 .numberOfConsumers = 0,
21648 .scale = 0.0f,
21649 .type = TestOperandType::TENSOR_FLOAT32,
21650 .zeroPoint = 0
21651 }, { // op1_new
21652 .channelQuant = {},
21653 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
21654 .dimensions = {2, 2, 2, 5},
21655 .isIgnored = false,
21656 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21657 .numberOfConsumers = 1,
21658 .scale = 0.0f,
21659 .type = TestOperandType::TENSOR_FLOAT32,
21660 .zeroPoint = 0
21661 }, { // placeholder131
21662 .channelQuant = {},
21663 .data = TestBuffer::createFromVector<float>({0.0f}),
21664 .dimensions = {1},
21665 .isIgnored = false,
21666 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21667 .numberOfConsumers = 1,
21668 .scale = 0.0f,
21669 .type = TestOperandType::TENSOR_FLOAT32,
21670 .zeroPoint = 0
21671 }, { // param149
21672 .channelQuant = {},
21673 .data = TestBuffer::createFromVector<int32_t>({0}),
21674 .dimensions = {},
21675 .isIgnored = false,
21676 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21677 .numberOfConsumers = 1,
21678 .scale = 0.0f,
21679 .type = TestOperandType::INT32,
21680 .zeroPoint = 0
21681 }},
21682 .operations = {{
21683 .inputs = {4, 5, 6},
21684 .outputs = {0},
21685 .type = TestOperationType::ADD
21686 }, {
21687 .inputs = {0, 1, 2},
21688 .outputs = {3},
21689 .type = TestOperationType::SOFTMAX
21690 }},
21691 .outputIndexes = {3}
21692 },
21693 .minSupportedVersion = TestHalVersion::UNKNOWN,
21694 .referenced = {}
21695 };
21696 return model;
21697 }
21698
21699 const auto dummy_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim4_axis3_neg_all_inputs_as_internal_2());
21700
21701 } // namespace generated_tests::softmax_v1_2
21702
21703 namespace generated_tests::softmax_v1_2 {
21704
get_test_model_axis_relaxed_dim3_axis0_2()21705 const TestModel& get_test_model_axis_relaxed_dim3_axis0_2() {
21706 static TestModel model = {
21707 .expectFailure = false,
21708 .expectedMultinomialDistributionTolerance = 0,
21709 .isRelaxed = true,
21710 .main = { // axis
21711 .inputIndexes = {0},
21712 .operands = {{ // op1
21713 .channelQuant = {},
21714 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
21715 .dimensions = {5, 2, 2},
21716 .isIgnored = false,
21717 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21718 .numberOfConsumers = 1,
21719 .scale = 0.0f,
21720 .type = TestOperandType::TENSOR_FLOAT32,
21721 .zeroPoint = 0
21722 }, { // param3
21723 .channelQuant = {},
21724 .data = TestBuffer::createFromVector<float>({1e-06f}),
21725 .dimensions = {},
21726 .isIgnored = false,
21727 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21728 .numberOfConsumers = 1,
21729 .scale = 0.0f,
21730 .type = TestOperandType::FLOAT32,
21731 .zeroPoint = 0
21732 }, { // axis
21733 .channelQuant = {},
21734 .data = TestBuffer::createFromVector<int32_t>({0}),
21735 .dimensions = {},
21736 .isIgnored = false,
21737 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21738 .numberOfConsumers = 1,
21739 .scale = 0.0f,
21740 .type = TestOperandType::INT32,
21741 .zeroPoint = 0
21742 }, { // op2
21743 .channelQuant = {},
21744 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21745 .dimensions = {5, 2, 2},
21746 .isIgnored = false,
21747 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21748 .numberOfConsumers = 0,
21749 .scale = 0.0f,
21750 .type = TestOperandType::TENSOR_FLOAT32,
21751 .zeroPoint = 0
21752 }},
21753 .operations = {{
21754 .inputs = {0, 1, 2},
21755 .outputs = {3},
21756 .type = TestOperationType::SOFTMAX
21757 }},
21758 .outputIndexes = {3}
21759 },
21760 .minSupportedVersion = TestHalVersion::UNKNOWN,
21761 .referenced = {}
21762 };
21763 return model;
21764 }
21765
21766 const auto dummy_test_model_axis_relaxed_dim3_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0_2", get_test_model_axis_relaxed_dim3_axis0_2());
21767
21768 } // namespace generated_tests::softmax_v1_2
21769
21770 namespace generated_tests::softmax_v1_2 {
21771
get_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal_2()21772 const TestModel& get_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal_2() {
21773 static TestModel model = {
21774 .expectFailure = false,
21775 .expectedMultinomialDistributionTolerance = 0,
21776 .isRelaxed = true,
21777 .main = { // axis
21778 .inputIndexes = {4},
21779 .operands = {{ // op1
21780 .channelQuant = {},
21781 .data = TestBuffer::createFromVector<float>({}),
21782 .dimensions = {5, 2, 2},
21783 .isIgnored = false,
21784 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
21785 .numberOfConsumers = 1,
21786 .scale = 0.0f,
21787 .type = TestOperandType::TENSOR_FLOAT32,
21788 .zeroPoint = 0
21789 }, { // param3
21790 .channelQuant = {},
21791 .data = TestBuffer::createFromVector<float>({1e-06f}),
21792 .dimensions = {},
21793 .isIgnored = false,
21794 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21795 .numberOfConsumers = 1,
21796 .scale = 0.0f,
21797 .type = TestOperandType::FLOAT32,
21798 .zeroPoint = 0
21799 }, { // axis
21800 .channelQuant = {},
21801 .data = TestBuffer::createFromVector<int32_t>({0}),
21802 .dimensions = {},
21803 .isIgnored = false,
21804 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21805 .numberOfConsumers = 1,
21806 .scale = 0.0f,
21807 .type = TestOperandType::INT32,
21808 .zeroPoint = 0
21809 }, { // op2
21810 .channelQuant = {},
21811 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21812 .dimensions = {5, 2, 2},
21813 .isIgnored = false,
21814 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21815 .numberOfConsumers = 0,
21816 .scale = 0.0f,
21817 .type = TestOperandType::TENSOR_FLOAT32,
21818 .zeroPoint = 0
21819 }, { // op1_new
21820 .channelQuant = {},
21821 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
21822 .dimensions = {5, 2, 2},
21823 .isIgnored = false,
21824 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21825 .numberOfConsumers = 1,
21826 .scale = 0.0f,
21827 .type = TestOperandType::TENSOR_FLOAT32,
21828 .zeroPoint = 0
21829 }, { // placeholder132
21830 .channelQuant = {},
21831 .data = TestBuffer::createFromVector<float>({0.0f}),
21832 .dimensions = {1},
21833 .isIgnored = false,
21834 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21835 .numberOfConsumers = 1,
21836 .scale = 0.0f,
21837 .type = TestOperandType::TENSOR_FLOAT32,
21838 .zeroPoint = 0
21839 }, { // param150
21840 .channelQuant = {},
21841 .data = TestBuffer::createFromVector<int32_t>({0}),
21842 .dimensions = {},
21843 .isIgnored = false,
21844 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21845 .numberOfConsumers = 1,
21846 .scale = 0.0f,
21847 .type = TestOperandType::INT32,
21848 .zeroPoint = 0
21849 }},
21850 .operations = {{
21851 .inputs = {4, 5, 6},
21852 .outputs = {0},
21853 .type = TestOperationType::ADD
21854 }, {
21855 .inputs = {0, 1, 2},
21856 .outputs = {3},
21857 .type = TestOperationType::SOFTMAX
21858 }},
21859 .outputIndexes = {3}
21860 },
21861 .minSupportedVersion = TestHalVersion::UNKNOWN,
21862 .referenced = {}
21863 };
21864 return model;
21865 }
21866
21867 const auto dummy_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim3_axis0_all_inputs_as_internal_2());
21868
21869 } // namespace generated_tests::softmax_v1_2
21870
21871 namespace generated_tests::softmax_v1_2 {
21872
get_test_model_axis_relaxed_dim3_axis0_neg_2()21873 const TestModel& get_test_model_axis_relaxed_dim3_axis0_neg_2() {
21874 static TestModel model = {
21875 .expectFailure = false,
21876 .expectedMultinomialDistributionTolerance = 0,
21877 .isRelaxed = true,
21878 .main = { // axis
21879 .inputIndexes = {0},
21880 .operands = {{ // op1
21881 .channelQuant = {},
21882 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
21883 .dimensions = {5, 2, 2},
21884 .isIgnored = false,
21885 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21886 .numberOfConsumers = 1,
21887 .scale = 0.0f,
21888 .type = TestOperandType::TENSOR_FLOAT32,
21889 .zeroPoint = 0
21890 }, { // param3
21891 .channelQuant = {},
21892 .data = TestBuffer::createFromVector<float>({1e-06f}),
21893 .dimensions = {},
21894 .isIgnored = false,
21895 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21896 .numberOfConsumers = 1,
21897 .scale = 0.0f,
21898 .type = TestOperandType::FLOAT32,
21899 .zeroPoint = 0
21900 }, { // axis
21901 .channelQuant = {},
21902 .data = TestBuffer::createFromVector<int32_t>({-3}),
21903 .dimensions = {},
21904 .isIgnored = false,
21905 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21906 .numberOfConsumers = 1,
21907 .scale = 0.0f,
21908 .type = TestOperandType::INT32,
21909 .zeroPoint = 0
21910 }, { // op2
21911 .channelQuant = {},
21912 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21913 .dimensions = {5, 2, 2},
21914 .isIgnored = false,
21915 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21916 .numberOfConsumers = 0,
21917 .scale = 0.0f,
21918 .type = TestOperandType::TENSOR_FLOAT32,
21919 .zeroPoint = 0
21920 }},
21921 .operations = {{
21922 .inputs = {0, 1, 2},
21923 .outputs = {3},
21924 .type = TestOperationType::SOFTMAX
21925 }},
21926 .outputIndexes = {3}
21927 },
21928 .minSupportedVersion = TestHalVersion::UNKNOWN,
21929 .referenced = {}
21930 };
21931 return model;
21932 }
21933
21934 const auto dummy_test_model_axis_relaxed_dim3_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0_neg_2", get_test_model_axis_relaxed_dim3_axis0_neg_2());
21935
21936 } // namespace generated_tests::softmax_v1_2
21937
21938 namespace generated_tests::softmax_v1_2 {
21939
get_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal_2()21940 const TestModel& get_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal_2() {
21941 static TestModel model = {
21942 .expectFailure = false,
21943 .expectedMultinomialDistributionTolerance = 0,
21944 .isRelaxed = true,
21945 .main = { // axis
21946 .inputIndexes = {4},
21947 .operands = {{ // op1
21948 .channelQuant = {},
21949 .data = TestBuffer::createFromVector<float>({}),
21950 .dimensions = {5, 2, 2},
21951 .isIgnored = false,
21952 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
21953 .numberOfConsumers = 1,
21954 .scale = 0.0f,
21955 .type = TestOperandType::TENSOR_FLOAT32,
21956 .zeroPoint = 0
21957 }, { // param3
21958 .channelQuant = {},
21959 .data = TestBuffer::createFromVector<float>({1e-06f}),
21960 .dimensions = {},
21961 .isIgnored = false,
21962 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21963 .numberOfConsumers = 1,
21964 .scale = 0.0f,
21965 .type = TestOperandType::FLOAT32,
21966 .zeroPoint = 0
21967 }, { // axis
21968 .channelQuant = {},
21969 .data = TestBuffer::createFromVector<int32_t>({-3}),
21970 .dimensions = {},
21971 .isIgnored = false,
21972 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
21973 .numberOfConsumers = 1,
21974 .scale = 0.0f,
21975 .type = TestOperandType::INT32,
21976 .zeroPoint = 0
21977 }, { // op2
21978 .channelQuant = {},
21979 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
21980 .dimensions = {5, 2, 2},
21981 .isIgnored = false,
21982 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
21983 .numberOfConsumers = 0,
21984 .scale = 0.0f,
21985 .type = TestOperandType::TENSOR_FLOAT32,
21986 .zeroPoint = 0
21987 }, { // op1_new
21988 .channelQuant = {},
21989 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
21990 .dimensions = {5, 2, 2},
21991 .isIgnored = false,
21992 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
21993 .numberOfConsumers = 1,
21994 .scale = 0.0f,
21995 .type = TestOperandType::TENSOR_FLOAT32,
21996 .zeroPoint = 0
21997 }, { // placeholder133
21998 .channelQuant = {},
21999 .data = TestBuffer::createFromVector<float>({0.0f}),
22000 .dimensions = {1},
22001 .isIgnored = false,
22002 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22003 .numberOfConsumers = 1,
22004 .scale = 0.0f,
22005 .type = TestOperandType::TENSOR_FLOAT32,
22006 .zeroPoint = 0
22007 }, { // param151
22008 .channelQuant = {},
22009 .data = TestBuffer::createFromVector<int32_t>({0}),
22010 .dimensions = {},
22011 .isIgnored = false,
22012 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22013 .numberOfConsumers = 1,
22014 .scale = 0.0f,
22015 .type = TestOperandType::INT32,
22016 .zeroPoint = 0
22017 }},
22018 .operations = {{
22019 .inputs = {4, 5, 6},
22020 .outputs = {0},
22021 .type = TestOperationType::ADD
22022 }, {
22023 .inputs = {0, 1, 2},
22024 .outputs = {3},
22025 .type = TestOperationType::SOFTMAX
22026 }},
22027 .outputIndexes = {3}
22028 },
22029 .minSupportedVersion = TestHalVersion::UNKNOWN,
22030 .referenced = {}
22031 };
22032 return model;
22033 }
22034
22035 const auto dummy_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim3_axis0_neg_all_inputs_as_internal_2());
22036
22037 } // namespace generated_tests::softmax_v1_2
22038
22039 namespace generated_tests::softmax_v1_2 {
22040
get_test_model_axis_relaxed_dim3_axis1_2()22041 const TestModel& get_test_model_axis_relaxed_dim3_axis1_2() {
22042 static TestModel model = {
22043 .expectFailure = false,
22044 .expectedMultinomialDistributionTolerance = 0,
22045 .isRelaxed = true,
22046 .main = { // axis
22047 .inputIndexes = {0},
22048 .operands = {{ // op1
22049 .channelQuant = {},
22050 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22051 .dimensions = {2, 5, 2},
22052 .isIgnored = false,
22053 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22054 .numberOfConsumers = 1,
22055 .scale = 0.0f,
22056 .type = TestOperandType::TENSOR_FLOAT32,
22057 .zeroPoint = 0
22058 }, { // param3
22059 .channelQuant = {},
22060 .data = TestBuffer::createFromVector<float>({1e-06f}),
22061 .dimensions = {},
22062 .isIgnored = false,
22063 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22064 .numberOfConsumers = 1,
22065 .scale = 0.0f,
22066 .type = TestOperandType::FLOAT32,
22067 .zeroPoint = 0
22068 }, { // axis
22069 .channelQuant = {},
22070 .data = TestBuffer::createFromVector<int32_t>({1}),
22071 .dimensions = {},
22072 .isIgnored = false,
22073 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22074 .numberOfConsumers = 1,
22075 .scale = 0.0f,
22076 .type = TestOperandType::INT32,
22077 .zeroPoint = 0
22078 }, { // op2
22079 .channelQuant = {},
22080 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22081 .dimensions = {2, 5, 2},
22082 .isIgnored = false,
22083 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22084 .numberOfConsumers = 0,
22085 .scale = 0.0f,
22086 .type = TestOperandType::TENSOR_FLOAT32,
22087 .zeroPoint = 0
22088 }},
22089 .operations = {{
22090 .inputs = {0, 1, 2},
22091 .outputs = {3},
22092 .type = TestOperationType::SOFTMAX
22093 }},
22094 .outputIndexes = {3}
22095 },
22096 .minSupportedVersion = TestHalVersion::UNKNOWN,
22097 .referenced = {}
22098 };
22099 return model;
22100 }
22101
22102 const auto dummy_test_model_axis_relaxed_dim3_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1_2", get_test_model_axis_relaxed_dim3_axis1_2());
22103
22104 } // namespace generated_tests::softmax_v1_2
22105
22106 namespace generated_tests::softmax_v1_2 {
22107
get_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal_2()22108 const TestModel& get_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal_2() {
22109 static TestModel model = {
22110 .expectFailure = false,
22111 .expectedMultinomialDistributionTolerance = 0,
22112 .isRelaxed = true,
22113 .main = { // axis
22114 .inputIndexes = {4},
22115 .operands = {{ // op1
22116 .channelQuant = {},
22117 .data = TestBuffer::createFromVector<float>({}),
22118 .dimensions = {2, 5, 2},
22119 .isIgnored = false,
22120 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
22121 .numberOfConsumers = 1,
22122 .scale = 0.0f,
22123 .type = TestOperandType::TENSOR_FLOAT32,
22124 .zeroPoint = 0
22125 }, { // param3
22126 .channelQuant = {},
22127 .data = TestBuffer::createFromVector<float>({1e-06f}),
22128 .dimensions = {},
22129 .isIgnored = false,
22130 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22131 .numberOfConsumers = 1,
22132 .scale = 0.0f,
22133 .type = TestOperandType::FLOAT32,
22134 .zeroPoint = 0
22135 }, { // axis
22136 .channelQuant = {},
22137 .data = TestBuffer::createFromVector<int32_t>({1}),
22138 .dimensions = {},
22139 .isIgnored = false,
22140 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22141 .numberOfConsumers = 1,
22142 .scale = 0.0f,
22143 .type = TestOperandType::INT32,
22144 .zeroPoint = 0
22145 }, { // op2
22146 .channelQuant = {},
22147 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22148 .dimensions = {2, 5, 2},
22149 .isIgnored = false,
22150 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22151 .numberOfConsumers = 0,
22152 .scale = 0.0f,
22153 .type = TestOperandType::TENSOR_FLOAT32,
22154 .zeroPoint = 0
22155 }, { // op1_new
22156 .channelQuant = {},
22157 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22158 .dimensions = {2, 5, 2},
22159 .isIgnored = false,
22160 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22161 .numberOfConsumers = 1,
22162 .scale = 0.0f,
22163 .type = TestOperandType::TENSOR_FLOAT32,
22164 .zeroPoint = 0
22165 }, { // placeholder134
22166 .channelQuant = {},
22167 .data = TestBuffer::createFromVector<float>({0.0f}),
22168 .dimensions = {1},
22169 .isIgnored = false,
22170 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22171 .numberOfConsumers = 1,
22172 .scale = 0.0f,
22173 .type = TestOperandType::TENSOR_FLOAT32,
22174 .zeroPoint = 0
22175 }, { // param152
22176 .channelQuant = {},
22177 .data = TestBuffer::createFromVector<int32_t>({0}),
22178 .dimensions = {},
22179 .isIgnored = false,
22180 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22181 .numberOfConsumers = 1,
22182 .scale = 0.0f,
22183 .type = TestOperandType::INT32,
22184 .zeroPoint = 0
22185 }},
22186 .operations = {{
22187 .inputs = {4, 5, 6},
22188 .outputs = {0},
22189 .type = TestOperationType::ADD
22190 }, {
22191 .inputs = {0, 1, 2},
22192 .outputs = {3},
22193 .type = TestOperationType::SOFTMAX
22194 }},
22195 .outputIndexes = {3}
22196 },
22197 .minSupportedVersion = TestHalVersion::UNKNOWN,
22198 .referenced = {}
22199 };
22200 return model;
22201 }
22202
22203 const auto dummy_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim3_axis1_all_inputs_as_internal_2());
22204
22205 } // namespace generated_tests::softmax_v1_2
22206
22207 namespace generated_tests::softmax_v1_2 {
22208
get_test_model_axis_relaxed_dim3_axis1_neg_2()22209 const TestModel& get_test_model_axis_relaxed_dim3_axis1_neg_2() {
22210 static TestModel model = {
22211 .expectFailure = false,
22212 .expectedMultinomialDistributionTolerance = 0,
22213 .isRelaxed = true,
22214 .main = { // axis
22215 .inputIndexes = {0},
22216 .operands = {{ // op1
22217 .channelQuant = {},
22218 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22219 .dimensions = {2, 5, 2},
22220 .isIgnored = false,
22221 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22222 .numberOfConsumers = 1,
22223 .scale = 0.0f,
22224 .type = TestOperandType::TENSOR_FLOAT32,
22225 .zeroPoint = 0
22226 }, { // param3
22227 .channelQuant = {},
22228 .data = TestBuffer::createFromVector<float>({1e-06f}),
22229 .dimensions = {},
22230 .isIgnored = false,
22231 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22232 .numberOfConsumers = 1,
22233 .scale = 0.0f,
22234 .type = TestOperandType::FLOAT32,
22235 .zeroPoint = 0
22236 }, { // axis
22237 .channelQuant = {},
22238 .data = TestBuffer::createFromVector<int32_t>({-2}),
22239 .dimensions = {},
22240 .isIgnored = false,
22241 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22242 .numberOfConsumers = 1,
22243 .scale = 0.0f,
22244 .type = TestOperandType::INT32,
22245 .zeroPoint = 0
22246 }, { // op2
22247 .channelQuant = {},
22248 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22249 .dimensions = {2, 5, 2},
22250 .isIgnored = false,
22251 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22252 .numberOfConsumers = 0,
22253 .scale = 0.0f,
22254 .type = TestOperandType::TENSOR_FLOAT32,
22255 .zeroPoint = 0
22256 }},
22257 .operations = {{
22258 .inputs = {0, 1, 2},
22259 .outputs = {3},
22260 .type = TestOperationType::SOFTMAX
22261 }},
22262 .outputIndexes = {3}
22263 },
22264 .minSupportedVersion = TestHalVersion::UNKNOWN,
22265 .referenced = {}
22266 };
22267 return model;
22268 }
22269
22270 const auto dummy_test_model_axis_relaxed_dim3_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1_neg_2", get_test_model_axis_relaxed_dim3_axis1_neg_2());
22271
22272 } // namespace generated_tests::softmax_v1_2
22273
22274 namespace generated_tests::softmax_v1_2 {
22275
get_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal_2()22276 const TestModel& get_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal_2() {
22277 static TestModel model = {
22278 .expectFailure = false,
22279 .expectedMultinomialDistributionTolerance = 0,
22280 .isRelaxed = true,
22281 .main = { // axis
22282 .inputIndexes = {4},
22283 .operands = {{ // op1
22284 .channelQuant = {},
22285 .data = TestBuffer::createFromVector<float>({}),
22286 .dimensions = {2, 5, 2},
22287 .isIgnored = false,
22288 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
22289 .numberOfConsumers = 1,
22290 .scale = 0.0f,
22291 .type = TestOperandType::TENSOR_FLOAT32,
22292 .zeroPoint = 0
22293 }, { // param3
22294 .channelQuant = {},
22295 .data = TestBuffer::createFromVector<float>({1e-06f}),
22296 .dimensions = {},
22297 .isIgnored = false,
22298 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22299 .numberOfConsumers = 1,
22300 .scale = 0.0f,
22301 .type = TestOperandType::FLOAT32,
22302 .zeroPoint = 0
22303 }, { // axis
22304 .channelQuant = {},
22305 .data = TestBuffer::createFromVector<int32_t>({-2}),
22306 .dimensions = {},
22307 .isIgnored = false,
22308 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22309 .numberOfConsumers = 1,
22310 .scale = 0.0f,
22311 .type = TestOperandType::INT32,
22312 .zeroPoint = 0
22313 }, { // op2
22314 .channelQuant = {},
22315 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22316 .dimensions = {2, 5, 2},
22317 .isIgnored = false,
22318 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22319 .numberOfConsumers = 0,
22320 .scale = 0.0f,
22321 .type = TestOperandType::TENSOR_FLOAT32,
22322 .zeroPoint = 0
22323 }, { // op1_new
22324 .channelQuant = {},
22325 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22326 .dimensions = {2, 5, 2},
22327 .isIgnored = false,
22328 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22329 .numberOfConsumers = 1,
22330 .scale = 0.0f,
22331 .type = TestOperandType::TENSOR_FLOAT32,
22332 .zeroPoint = 0
22333 }, { // placeholder135
22334 .channelQuant = {},
22335 .data = TestBuffer::createFromVector<float>({0.0f}),
22336 .dimensions = {1},
22337 .isIgnored = false,
22338 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22339 .numberOfConsumers = 1,
22340 .scale = 0.0f,
22341 .type = TestOperandType::TENSOR_FLOAT32,
22342 .zeroPoint = 0
22343 }, { // param153
22344 .channelQuant = {},
22345 .data = TestBuffer::createFromVector<int32_t>({0}),
22346 .dimensions = {},
22347 .isIgnored = false,
22348 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22349 .numberOfConsumers = 1,
22350 .scale = 0.0f,
22351 .type = TestOperandType::INT32,
22352 .zeroPoint = 0
22353 }},
22354 .operations = {{
22355 .inputs = {4, 5, 6},
22356 .outputs = {0},
22357 .type = TestOperationType::ADD
22358 }, {
22359 .inputs = {0, 1, 2},
22360 .outputs = {3},
22361 .type = TestOperationType::SOFTMAX
22362 }},
22363 .outputIndexes = {3}
22364 },
22365 .minSupportedVersion = TestHalVersion::UNKNOWN,
22366 .referenced = {}
22367 };
22368 return model;
22369 }
22370
22371 const auto dummy_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim3_axis1_neg_all_inputs_as_internal_2());
22372
22373 } // namespace generated_tests::softmax_v1_2
22374
22375 namespace generated_tests::softmax_v1_2 {
22376
get_test_model_axis_relaxed_dim3_axis2_2()22377 const TestModel& get_test_model_axis_relaxed_dim3_axis2_2() {
22378 static TestModel model = {
22379 .expectFailure = false,
22380 .expectedMultinomialDistributionTolerance = 0,
22381 .isRelaxed = true,
22382 .main = { // axis
22383 .inputIndexes = {0},
22384 .operands = {{ // op1
22385 .channelQuant = {},
22386 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
22387 .dimensions = {2, 2, 5},
22388 .isIgnored = false,
22389 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22390 .numberOfConsumers = 1,
22391 .scale = 0.0f,
22392 .type = TestOperandType::TENSOR_FLOAT32,
22393 .zeroPoint = 0
22394 }, { // param3
22395 .channelQuant = {},
22396 .data = TestBuffer::createFromVector<float>({1e-06f}),
22397 .dimensions = {},
22398 .isIgnored = false,
22399 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22400 .numberOfConsumers = 1,
22401 .scale = 0.0f,
22402 .type = TestOperandType::FLOAT32,
22403 .zeroPoint = 0
22404 }, { // axis
22405 .channelQuant = {},
22406 .data = TestBuffer::createFromVector<int32_t>({2}),
22407 .dimensions = {},
22408 .isIgnored = false,
22409 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22410 .numberOfConsumers = 1,
22411 .scale = 0.0f,
22412 .type = TestOperandType::INT32,
22413 .zeroPoint = 0
22414 }, { // op2
22415 .channelQuant = {},
22416 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22417 .dimensions = {2, 2, 5},
22418 .isIgnored = false,
22419 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22420 .numberOfConsumers = 0,
22421 .scale = 0.0f,
22422 .type = TestOperandType::TENSOR_FLOAT32,
22423 .zeroPoint = 0
22424 }},
22425 .operations = {{
22426 .inputs = {0, 1, 2},
22427 .outputs = {3},
22428 .type = TestOperationType::SOFTMAX
22429 }},
22430 .outputIndexes = {3}
22431 },
22432 .minSupportedVersion = TestHalVersion::UNKNOWN,
22433 .referenced = {}
22434 };
22435 return model;
22436 }
22437
22438 const auto dummy_test_model_axis_relaxed_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2_2", get_test_model_axis_relaxed_dim3_axis2_2());
22439
22440 } // namespace generated_tests::softmax_v1_2
22441
22442 namespace generated_tests::softmax_v1_2 {
22443
get_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal_2()22444 const TestModel& get_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal_2() {
22445 static TestModel model = {
22446 .expectFailure = false,
22447 .expectedMultinomialDistributionTolerance = 0,
22448 .isRelaxed = true,
22449 .main = { // axis
22450 .inputIndexes = {4},
22451 .operands = {{ // op1
22452 .channelQuant = {},
22453 .data = TestBuffer::createFromVector<float>({}),
22454 .dimensions = {2, 2, 5},
22455 .isIgnored = false,
22456 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
22457 .numberOfConsumers = 1,
22458 .scale = 0.0f,
22459 .type = TestOperandType::TENSOR_FLOAT32,
22460 .zeroPoint = 0
22461 }, { // param3
22462 .channelQuant = {},
22463 .data = TestBuffer::createFromVector<float>({1e-06f}),
22464 .dimensions = {},
22465 .isIgnored = false,
22466 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22467 .numberOfConsumers = 1,
22468 .scale = 0.0f,
22469 .type = TestOperandType::FLOAT32,
22470 .zeroPoint = 0
22471 }, { // axis
22472 .channelQuant = {},
22473 .data = TestBuffer::createFromVector<int32_t>({2}),
22474 .dimensions = {},
22475 .isIgnored = false,
22476 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22477 .numberOfConsumers = 1,
22478 .scale = 0.0f,
22479 .type = TestOperandType::INT32,
22480 .zeroPoint = 0
22481 }, { // op2
22482 .channelQuant = {},
22483 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22484 .dimensions = {2, 2, 5},
22485 .isIgnored = false,
22486 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22487 .numberOfConsumers = 0,
22488 .scale = 0.0f,
22489 .type = TestOperandType::TENSOR_FLOAT32,
22490 .zeroPoint = 0
22491 }, { // op1_new
22492 .channelQuant = {},
22493 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
22494 .dimensions = {2, 2, 5},
22495 .isIgnored = false,
22496 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22497 .numberOfConsumers = 1,
22498 .scale = 0.0f,
22499 .type = TestOperandType::TENSOR_FLOAT32,
22500 .zeroPoint = 0
22501 }, { // placeholder136
22502 .channelQuant = {},
22503 .data = TestBuffer::createFromVector<float>({0.0f}),
22504 .dimensions = {1},
22505 .isIgnored = false,
22506 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22507 .numberOfConsumers = 1,
22508 .scale = 0.0f,
22509 .type = TestOperandType::TENSOR_FLOAT32,
22510 .zeroPoint = 0
22511 }, { // param154
22512 .channelQuant = {},
22513 .data = TestBuffer::createFromVector<int32_t>({0}),
22514 .dimensions = {},
22515 .isIgnored = false,
22516 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22517 .numberOfConsumers = 1,
22518 .scale = 0.0f,
22519 .type = TestOperandType::INT32,
22520 .zeroPoint = 0
22521 }},
22522 .operations = {{
22523 .inputs = {4, 5, 6},
22524 .outputs = {0},
22525 .type = TestOperationType::ADD
22526 }, {
22527 .inputs = {0, 1, 2},
22528 .outputs = {3},
22529 .type = TestOperationType::SOFTMAX
22530 }},
22531 .outputIndexes = {3}
22532 },
22533 .minSupportedVersion = TestHalVersion::UNKNOWN,
22534 .referenced = {}
22535 };
22536 return model;
22537 }
22538
22539 const auto dummy_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim3_axis2_all_inputs_as_internal_2());
22540
22541 } // namespace generated_tests::softmax_v1_2
22542
22543 namespace generated_tests::softmax_v1_2 {
22544
get_test_model_axis_relaxed_dim3_axis2_neg_2()22545 const TestModel& get_test_model_axis_relaxed_dim3_axis2_neg_2() {
22546 static TestModel model = {
22547 .expectFailure = false,
22548 .expectedMultinomialDistributionTolerance = 0,
22549 .isRelaxed = true,
22550 .main = { // axis
22551 .inputIndexes = {0},
22552 .operands = {{ // op1
22553 .channelQuant = {},
22554 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
22555 .dimensions = {2, 2, 5},
22556 .isIgnored = false,
22557 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22558 .numberOfConsumers = 1,
22559 .scale = 0.0f,
22560 .type = TestOperandType::TENSOR_FLOAT32,
22561 .zeroPoint = 0
22562 }, { // param3
22563 .channelQuant = {},
22564 .data = TestBuffer::createFromVector<float>({1e-06f}),
22565 .dimensions = {},
22566 .isIgnored = false,
22567 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22568 .numberOfConsumers = 1,
22569 .scale = 0.0f,
22570 .type = TestOperandType::FLOAT32,
22571 .zeroPoint = 0
22572 }, { // axis
22573 .channelQuant = {},
22574 .data = TestBuffer::createFromVector<int32_t>({-1}),
22575 .dimensions = {},
22576 .isIgnored = false,
22577 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22578 .numberOfConsumers = 1,
22579 .scale = 0.0f,
22580 .type = TestOperandType::INT32,
22581 .zeroPoint = 0
22582 }, { // op2
22583 .channelQuant = {},
22584 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22585 .dimensions = {2, 2, 5},
22586 .isIgnored = false,
22587 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22588 .numberOfConsumers = 0,
22589 .scale = 0.0f,
22590 .type = TestOperandType::TENSOR_FLOAT32,
22591 .zeroPoint = 0
22592 }},
22593 .operations = {{
22594 .inputs = {0, 1, 2},
22595 .outputs = {3},
22596 .type = TestOperationType::SOFTMAX
22597 }},
22598 .outputIndexes = {3}
22599 },
22600 .minSupportedVersion = TestHalVersion::UNKNOWN,
22601 .referenced = {}
22602 };
22603 return model;
22604 }
22605
22606 const auto dummy_test_model_axis_relaxed_dim3_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2_neg_2", get_test_model_axis_relaxed_dim3_axis2_neg_2());
22607
22608 } // namespace generated_tests::softmax_v1_2
22609
22610 namespace generated_tests::softmax_v1_2 {
22611
get_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal_2()22612 const TestModel& get_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal_2() {
22613 static TestModel model = {
22614 .expectFailure = false,
22615 .expectedMultinomialDistributionTolerance = 0,
22616 .isRelaxed = true,
22617 .main = { // axis
22618 .inputIndexes = {4},
22619 .operands = {{ // op1
22620 .channelQuant = {},
22621 .data = TestBuffer::createFromVector<float>({}),
22622 .dimensions = {2, 2, 5},
22623 .isIgnored = false,
22624 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
22625 .numberOfConsumers = 1,
22626 .scale = 0.0f,
22627 .type = TestOperandType::TENSOR_FLOAT32,
22628 .zeroPoint = 0
22629 }, { // param3
22630 .channelQuant = {},
22631 .data = TestBuffer::createFromVector<float>({1e-06f}),
22632 .dimensions = {},
22633 .isIgnored = false,
22634 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22635 .numberOfConsumers = 1,
22636 .scale = 0.0f,
22637 .type = TestOperandType::FLOAT32,
22638 .zeroPoint = 0
22639 }, { // axis
22640 .channelQuant = {},
22641 .data = TestBuffer::createFromVector<int32_t>({-1}),
22642 .dimensions = {},
22643 .isIgnored = false,
22644 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22645 .numberOfConsumers = 1,
22646 .scale = 0.0f,
22647 .type = TestOperandType::INT32,
22648 .zeroPoint = 0
22649 }, { // op2
22650 .channelQuant = {},
22651 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22652 .dimensions = {2, 2, 5},
22653 .isIgnored = false,
22654 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22655 .numberOfConsumers = 0,
22656 .scale = 0.0f,
22657 .type = TestOperandType::TENSOR_FLOAT32,
22658 .zeroPoint = 0
22659 }, { // op1_new
22660 .channelQuant = {},
22661 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
22662 .dimensions = {2, 2, 5},
22663 .isIgnored = false,
22664 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22665 .numberOfConsumers = 1,
22666 .scale = 0.0f,
22667 .type = TestOperandType::TENSOR_FLOAT32,
22668 .zeroPoint = 0
22669 }, { // placeholder137
22670 .channelQuant = {},
22671 .data = TestBuffer::createFromVector<float>({0.0f}),
22672 .dimensions = {1},
22673 .isIgnored = false,
22674 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22675 .numberOfConsumers = 1,
22676 .scale = 0.0f,
22677 .type = TestOperandType::TENSOR_FLOAT32,
22678 .zeroPoint = 0
22679 }, { // param155
22680 .channelQuant = {},
22681 .data = TestBuffer::createFromVector<int32_t>({0}),
22682 .dimensions = {},
22683 .isIgnored = false,
22684 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22685 .numberOfConsumers = 1,
22686 .scale = 0.0f,
22687 .type = TestOperandType::INT32,
22688 .zeroPoint = 0
22689 }},
22690 .operations = {{
22691 .inputs = {4, 5, 6},
22692 .outputs = {0},
22693 .type = TestOperationType::ADD
22694 }, {
22695 .inputs = {0, 1, 2},
22696 .outputs = {3},
22697 .type = TestOperationType::SOFTMAX
22698 }},
22699 .outputIndexes = {3}
22700 },
22701 .minSupportedVersion = TestHalVersion::UNKNOWN,
22702 .referenced = {}
22703 };
22704 return model;
22705 }
22706
22707 const auto dummy_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim3_axis2_neg_all_inputs_as_internal_2());
22708
22709 } // namespace generated_tests::softmax_v1_2
22710
22711 namespace generated_tests::softmax_v1_2 {
22712
get_test_model_axis_relaxed_dim2_axis0_2()22713 const TestModel& get_test_model_axis_relaxed_dim2_axis0_2() {
22714 static TestModel model = {
22715 .expectFailure = false,
22716 .expectedMultinomialDistributionTolerance = 0,
22717 .isRelaxed = true,
22718 .main = { // axis
22719 .inputIndexes = {0},
22720 .operands = {{ // op1
22721 .channelQuant = {},
22722 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22723 .dimensions = {5, 2},
22724 .isIgnored = false,
22725 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22726 .numberOfConsumers = 1,
22727 .scale = 0.0f,
22728 .type = TestOperandType::TENSOR_FLOAT32,
22729 .zeroPoint = 0
22730 }, { // param3
22731 .channelQuant = {},
22732 .data = TestBuffer::createFromVector<float>({1e-06f}),
22733 .dimensions = {},
22734 .isIgnored = false,
22735 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22736 .numberOfConsumers = 1,
22737 .scale = 0.0f,
22738 .type = TestOperandType::FLOAT32,
22739 .zeroPoint = 0
22740 }, { // axis
22741 .channelQuant = {},
22742 .data = TestBuffer::createFromVector<int32_t>({0}),
22743 .dimensions = {},
22744 .isIgnored = false,
22745 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22746 .numberOfConsumers = 1,
22747 .scale = 0.0f,
22748 .type = TestOperandType::INT32,
22749 .zeroPoint = 0
22750 }, { // op2
22751 .channelQuant = {},
22752 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22753 .dimensions = {5, 2},
22754 .isIgnored = false,
22755 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22756 .numberOfConsumers = 0,
22757 .scale = 0.0f,
22758 .type = TestOperandType::TENSOR_FLOAT32,
22759 .zeroPoint = 0
22760 }},
22761 .operations = {{
22762 .inputs = {0, 1, 2},
22763 .outputs = {3},
22764 .type = TestOperationType::SOFTMAX
22765 }},
22766 .outputIndexes = {3}
22767 },
22768 .minSupportedVersion = TestHalVersion::UNKNOWN,
22769 .referenced = {}
22770 };
22771 return model;
22772 }
22773
22774 const auto dummy_test_model_axis_relaxed_dim2_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0_2", get_test_model_axis_relaxed_dim2_axis0_2());
22775
22776 } // namespace generated_tests::softmax_v1_2
22777
22778 namespace generated_tests::softmax_v1_2 {
22779
get_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal_2()22780 const TestModel& get_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal_2() {
22781 static TestModel model = {
22782 .expectFailure = false,
22783 .expectedMultinomialDistributionTolerance = 0,
22784 .isRelaxed = true,
22785 .main = { // axis
22786 .inputIndexes = {4},
22787 .operands = {{ // op1
22788 .channelQuant = {},
22789 .data = TestBuffer::createFromVector<float>({}),
22790 .dimensions = {5, 2},
22791 .isIgnored = false,
22792 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
22793 .numberOfConsumers = 1,
22794 .scale = 0.0f,
22795 .type = TestOperandType::TENSOR_FLOAT32,
22796 .zeroPoint = 0
22797 }, { // param3
22798 .channelQuant = {},
22799 .data = TestBuffer::createFromVector<float>({1e-06f}),
22800 .dimensions = {},
22801 .isIgnored = false,
22802 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22803 .numberOfConsumers = 1,
22804 .scale = 0.0f,
22805 .type = TestOperandType::FLOAT32,
22806 .zeroPoint = 0
22807 }, { // axis
22808 .channelQuant = {},
22809 .data = TestBuffer::createFromVector<int32_t>({0}),
22810 .dimensions = {},
22811 .isIgnored = false,
22812 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22813 .numberOfConsumers = 1,
22814 .scale = 0.0f,
22815 .type = TestOperandType::INT32,
22816 .zeroPoint = 0
22817 }, { // op2
22818 .channelQuant = {},
22819 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22820 .dimensions = {5, 2},
22821 .isIgnored = false,
22822 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22823 .numberOfConsumers = 0,
22824 .scale = 0.0f,
22825 .type = TestOperandType::TENSOR_FLOAT32,
22826 .zeroPoint = 0
22827 }, { // op1_new
22828 .channelQuant = {},
22829 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22830 .dimensions = {5, 2},
22831 .isIgnored = false,
22832 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22833 .numberOfConsumers = 1,
22834 .scale = 0.0f,
22835 .type = TestOperandType::TENSOR_FLOAT32,
22836 .zeroPoint = 0
22837 }, { // placeholder138
22838 .channelQuant = {},
22839 .data = TestBuffer::createFromVector<float>({0.0f}),
22840 .dimensions = {1},
22841 .isIgnored = false,
22842 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22843 .numberOfConsumers = 1,
22844 .scale = 0.0f,
22845 .type = TestOperandType::TENSOR_FLOAT32,
22846 .zeroPoint = 0
22847 }, { // param156
22848 .channelQuant = {},
22849 .data = TestBuffer::createFromVector<int32_t>({0}),
22850 .dimensions = {},
22851 .isIgnored = false,
22852 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22853 .numberOfConsumers = 1,
22854 .scale = 0.0f,
22855 .type = TestOperandType::INT32,
22856 .zeroPoint = 0
22857 }},
22858 .operations = {{
22859 .inputs = {4, 5, 6},
22860 .outputs = {0},
22861 .type = TestOperationType::ADD
22862 }, {
22863 .inputs = {0, 1, 2},
22864 .outputs = {3},
22865 .type = TestOperationType::SOFTMAX
22866 }},
22867 .outputIndexes = {3}
22868 },
22869 .minSupportedVersion = TestHalVersion::UNKNOWN,
22870 .referenced = {}
22871 };
22872 return model;
22873 }
22874
22875 const auto dummy_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim2_axis0_all_inputs_as_internal_2());
22876
22877 } // namespace generated_tests::softmax_v1_2
22878
22879 namespace generated_tests::softmax_v1_2 {
22880
get_test_model_axis_relaxed_dim2_axis0_neg_2()22881 const TestModel& get_test_model_axis_relaxed_dim2_axis0_neg_2() {
22882 static TestModel model = {
22883 .expectFailure = false,
22884 .expectedMultinomialDistributionTolerance = 0,
22885 .isRelaxed = true,
22886 .main = { // axis
22887 .inputIndexes = {0},
22888 .operands = {{ // op1
22889 .channelQuant = {},
22890 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22891 .dimensions = {5, 2},
22892 .isIgnored = false,
22893 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22894 .numberOfConsumers = 1,
22895 .scale = 0.0f,
22896 .type = TestOperandType::TENSOR_FLOAT32,
22897 .zeroPoint = 0
22898 }, { // param3
22899 .channelQuant = {},
22900 .data = TestBuffer::createFromVector<float>({1e-06f}),
22901 .dimensions = {},
22902 .isIgnored = false,
22903 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22904 .numberOfConsumers = 1,
22905 .scale = 0.0f,
22906 .type = TestOperandType::FLOAT32,
22907 .zeroPoint = 0
22908 }, { // axis
22909 .channelQuant = {},
22910 .data = TestBuffer::createFromVector<int32_t>({-2}),
22911 .dimensions = {},
22912 .isIgnored = false,
22913 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22914 .numberOfConsumers = 1,
22915 .scale = 0.0f,
22916 .type = TestOperandType::INT32,
22917 .zeroPoint = 0
22918 }, { // op2
22919 .channelQuant = {},
22920 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22921 .dimensions = {5, 2},
22922 .isIgnored = false,
22923 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22924 .numberOfConsumers = 0,
22925 .scale = 0.0f,
22926 .type = TestOperandType::TENSOR_FLOAT32,
22927 .zeroPoint = 0
22928 }},
22929 .operations = {{
22930 .inputs = {0, 1, 2},
22931 .outputs = {3},
22932 .type = TestOperationType::SOFTMAX
22933 }},
22934 .outputIndexes = {3}
22935 },
22936 .minSupportedVersion = TestHalVersion::UNKNOWN,
22937 .referenced = {}
22938 };
22939 return model;
22940 }
22941
22942 const auto dummy_test_model_axis_relaxed_dim2_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0_neg_2", get_test_model_axis_relaxed_dim2_axis0_neg_2());
22943
22944 } // namespace generated_tests::softmax_v1_2
22945
22946 namespace generated_tests::softmax_v1_2 {
22947
get_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal_2()22948 const TestModel& get_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal_2() {
22949 static TestModel model = {
22950 .expectFailure = false,
22951 .expectedMultinomialDistributionTolerance = 0,
22952 .isRelaxed = true,
22953 .main = { // axis
22954 .inputIndexes = {4},
22955 .operands = {{ // op1
22956 .channelQuant = {},
22957 .data = TestBuffer::createFromVector<float>({}),
22958 .dimensions = {5, 2},
22959 .isIgnored = false,
22960 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
22961 .numberOfConsumers = 1,
22962 .scale = 0.0f,
22963 .type = TestOperandType::TENSOR_FLOAT32,
22964 .zeroPoint = 0
22965 }, { // param3
22966 .channelQuant = {},
22967 .data = TestBuffer::createFromVector<float>({1e-06f}),
22968 .dimensions = {},
22969 .isIgnored = false,
22970 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22971 .numberOfConsumers = 1,
22972 .scale = 0.0f,
22973 .type = TestOperandType::FLOAT32,
22974 .zeroPoint = 0
22975 }, { // axis
22976 .channelQuant = {},
22977 .data = TestBuffer::createFromVector<int32_t>({-2}),
22978 .dimensions = {},
22979 .isIgnored = false,
22980 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
22981 .numberOfConsumers = 1,
22982 .scale = 0.0f,
22983 .type = TestOperandType::INT32,
22984 .zeroPoint = 0
22985 }, { // op2
22986 .channelQuant = {},
22987 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
22988 .dimensions = {5, 2},
22989 .isIgnored = false,
22990 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
22991 .numberOfConsumers = 0,
22992 .scale = 0.0f,
22993 .type = TestOperandType::TENSOR_FLOAT32,
22994 .zeroPoint = 0
22995 }, { // op1_new
22996 .channelQuant = {},
22997 .data = TestBuffer::createFromVector<float>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
22998 .dimensions = {5, 2},
22999 .isIgnored = false,
23000 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23001 .numberOfConsumers = 1,
23002 .scale = 0.0f,
23003 .type = TestOperandType::TENSOR_FLOAT32,
23004 .zeroPoint = 0
23005 }, { // placeholder139
23006 .channelQuant = {},
23007 .data = TestBuffer::createFromVector<float>({0.0f}),
23008 .dimensions = {1},
23009 .isIgnored = false,
23010 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23011 .numberOfConsumers = 1,
23012 .scale = 0.0f,
23013 .type = TestOperandType::TENSOR_FLOAT32,
23014 .zeroPoint = 0
23015 }, { // param157
23016 .channelQuant = {},
23017 .data = TestBuffer::createFromVector<int32_t>({0}),
23018 .dimensions = {},
23019 .isIgnored = false,
23020 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23021 .numberOfConsumers = 1,
23022 .scale = 0.0f,
23023 .type = TestOperandType::INT32,
23024 .zeroPoint = 0
23025 }},
23026 .operations = {{
23027 .inputs = {4, 5, 6},
23028 .outputs = {0},
23029 .type = TestOperationType::ADD
23030 }, {
23031 .inputs = {0, 1, 2},
23032 .outputs = {3},
23033 .type = TestOperationType::SOFTMAX
23034 }},
23035 .outputIndexes = {3}
23036 },
23037 .minSupportedVersion = TestHalVersion::UNKNOWN,
23038 .referenced = {}
23039 };
23040 return model;
23041 }
23042
23043 const auto dummy_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim2_axis0_neg_all_inputs_as_internal_2());
23044
23045 } // namespace generated_tests::softmax_v1_2
23046
23047 namespace generated_tests::softmax_v1_2 {
23048
get_test_model_axis_relaxed_dim2_axis1_2()23049 const TestModel& get_test_model_axis_relaxed_dim2_axis1_2() {
23050 static TestModel model = {
23051 .expectFailure = false,
23052 .expectedMultinomialDistributionTolerance = 0,
23053 .isRelaxed = true,
23054 .main = { // axis
23055 .inputIndexes = {0},
23056 .operands = {{ // op1
23057 .channelQuant = {},
23058 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
23059 .dimensions = {2, 5},
23060 .isIgnored = false,
23061 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23062 .numberOfConsumers = 1,
23063 .scale = 0.0f,
23064 .type = TestOperandType::TENSOR_FLOAT32,
23065 .zeroPoint = 0
23066 }, { // param3
23067 .channelQuant = {},
23068 .data = TestBuffer::createFromVector<float>({1e-06f}),
23069 .dimensions = {},
23070 .isIgnored = false,
23071 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23072 .numberOfConsumers = 1,
23073 .scale = 0.0f,
23074 .type = TestOperandType::FLOAT32,
23075 .zeroPoint = 0
23076 }, { // axis
23077 .channelQuant = {},
23078 .data = TestBuffer::createFromVector<int32_t>({1}),
23079 .dimensions = {},
23080 .isIgnored = false,
23081 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23082 .numberOfConsumers = 1,
23083 .scale = 0.0f,
23084 .type = TestOperandType::INT32,
23085 .zeroPoint = 0
23086 }, { // op2
23087 .channelQuant = {},
23088 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23089 .dimensions = {2, 5},
23090 .isIgnored = false,
23091 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23092 .numberOfConsumers = 0,
23093 .scale = 0.0f,
23094 .type = TestOperandType::TENSOR_FLOAT32,
23095 .zeroPoint = 0
23096 }},
23097 .operations = {{
23098 .inputs = {0, 1, 2},
23099 .outputs = {3},
23100 .type = TestOperationType::SOFTMAX
23101 }},
23102 .outputIndexes = {3}
23103 },
23104 .minSupportedVersion = TestHalVersion::UNKNOWN,
23105 .referenced = {}
23106 };
23107 return model;
23108 }
23109
23110 const auto dummy_test_model_axis_relaxed_dim2_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1_2", get_test_model_axis_relaxed_dim2_axis1_2());
23111
23112 } // namespace generated_tests::softmax_v1_2
23113
23114 namespace generated_tests::softmax_v1_2 {
23115
get_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal_2()23116 const TestModel& get_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal_2() {
23117 static TestModel model = {
23118 .expectFailure = false,
23119 .expectedMultinomialDistributionTolerance = 0,
23120 .isRelaxed = true,
23121 .main = { // axis
23122 .inputIndexes = {4},
23123 .operands = {{ // op1
23124 .channelQuant = {},
23125 .data = TestBuffer::createFromVector<float>({}),
23126 .dimensions = {2, 5},
23127 .isIgnored = false,
23128 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
23129 .numberOfConsumers = 1,
23130 .scale = 0.0f,
23131 .type = TestOperandType::TENSOR_FLOAT32,
23132 .zeroPoint = 0
23133 }, { // param3
23134 .channelQuant = {},
23135 .data = TestBuffer::createFromVector<float>({1e-06f}),
23136 .dimensions = {},
23137 .isIgnored = false,
23138 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23139 .numberOfConsumers = 1,
23140 .scale = 0.0f,
23141 .type = TestOperandType::FLOAT32,
23142 .zeroPoint = 0
23143 }, { // axis
23144 .channelQuant = {},
23145 .data = TestBuffer::createFromVector<int32_t>({1}),
23146 .dimensions = {},
23147 .isIgnored = false,
23148 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23149 .numberOfConsumers = 1,
23150 .scale = 0.0f,
23151 .type = TestOperandType::INT32,
23152 .zeroPoint = 0
23153 }, { // op2
23154 .channelQuant = {},
23155 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23156 .dimensions = {2, 5},
23157 .isIgnored = false,
23158 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23159 .numberOfConsumers = 0,
23160 .scale = 0.0f,
23161 .type = TestOperandType::TENSOR_FLOAT32,
23162 .zeroPoint = 0
23163 }, { // op1_new
23164 .channelQuant = {},
23165 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
23166 .dimensions = {2, 5},
23167 .isIgnored = false,
23168 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23169 .numberOfConsumers = 1,
23170 .scale = 0.0f,
23171 .type = TestOperandType::TENSOR_FLOAT32,
23172 .zeroPoint = 0
23173 }, { // placeholder140
23174 .channelQuant = {},
23175 .data = TestBuffer::createFromVector<float>({0.0f}),
23176 .dimensions = {1},
23177 .isIgnored = false,
23178 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23179 .numberOfConsumers = 1,
23180 .scale = 0.0f,
23181 .type = TestOperandType::TENSOR_FLOAT32,
23182 .zeroPoint = 0
23183 }, { // param158
23184 .channelQuant = {},
23185 .data = TestBuffer::createFromVector<int32_t>({0}),
23186 .dimensions = {},
23187 .isIgnored = false,
23188 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23189 .numberOfConsumers = 1,
23190 .scale = 0.0f,
23191 .type = TestOperandType::INT32,
23192 .zeroPoint = 0
23193 }},
23194 .operations = {{
23195 .inputs = {4, 5, 6},
23196 .outputs = {0},
23197 .type = TestOperationType::ADD
23198 }, {
23199 .inputs = {0, 1, 2},
23200 .outputs = {3},
23201 .type = TestOperationType::SOFTMAX
23202 }},
23203 .outputIndexes = {3}
23204 },
23205 .minSupportedVersion = TestHalVersion::UNKNOWN,
23206 .referenced = {}
23207 };
23208 return model;
23209 }
23210
23211 const auto dummy_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim2_axis1_all_inputs_as_internal_2());
23212
23213 } // namespace generated_tests::softmax_v1_2
23214
23215 namespace generated_tests::softmax_v1_2 {
23216
get_test_model_axis_relaxed_dim2_axis1_neg_2()23217 const TestModel& get_test_model_axis_relaxed_dim2_axis1_neg_2() {
23218 static TestModel model = {
23219 .expectFailure = false,
23220 .expectedMultinomialDistributionTolerance = 0,
23221 .isRelaxed = true,
23222 .main = { // axis
23223 .inputIndexes = {0},
23224 .operands = {{ // op1
23225 .channelQuant = {},
23226 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
23227 .dimensions = {2, 5},
23228 .isIgnored = false,
23229 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23230 .numberOfConsumers = 1,
23231 .scale = 0.0f,
23232 .type = TestOperandType::TENSOR_FLOAT32,
23233 .zeroPoint = 0
23234 }, { // param3
23235 .channelQuant = {},
23236 .data = TestBuffer::createFromVector<float>({1e-06f}),
23237 .dimensions = {},
23238 .isIgnored = false,
23239 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23240 .numberOfConsumers = 1,
23241 .scale = 0.0f,
23242 .type = TestOperandType::FLOAT32,
23243 .zeroPoint = 0
23244 }, { // axis
23245 .channelQuant = {},
23246 .data = TestBuffer::createFromVector<int32_t>({-1}),
23247 .dimensions = {},
23248 .isIgnored = false,
23249 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23250 .numberOfConsumers = 1,
23251 .scale = 0.0f,
23252 .type = TestOperandType::INT32,
23253 .zeroPoint = 0
23254 }, { // op2
23255 .channelQuant = {},
23256 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23257 .dimensions = {2, 5},
23258 .isIgnored = false,
23259 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23260 .numberOfConsumers = 0,
23261 .scale = 0.0f,
23262 .type = TestOperandType::TENSOR_FLOAT32,
23263 .zeroPoint = 0
23264 }},
23265 .operations = {{
23266 .inputs = {0, 1, 2},
23267 .outputs = {3},
23268 .type = TestOperationType::SOFTMAX
23269 }},
23270 .outputIndexes = {3}
23271 },
23272 .minSupportedVersion = TestHalVersion::UNKNOWN,
23273 .referenced = {}
23274 };
23275 return model;
23276 }
23277
23278 const auto dummy_test_model_axis_relaxed_dim2_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1_neg_2", get_test_model_axis_relaxed_dim2_axis1_neg_2());
23279
23280 } // namespace generated_tests::softmax_v1_2
23281
23282 namespace generated_tests::softmax_v1_2 {
23283
get_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal_2()23284 const TestModel& get_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal_2() {
23285 static TestModel model = {
23286 .expectFailure = false,
23287 .expectedMultinomialDistributionTolerance = 0,
23288 .isRelaxed = true,
23289 .main = { // axis
23290 .inputIndexes = {4},
23291 .operands = {{ // op1
23292 .channelQuant = {},
23293 .data = TestBuffer::createFromVector<float>({}),
23294 .dimensions = {2, 5},
23295 .isIgnored = false,
23296 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
23297 .numberOfConsumers = 1,
23298 .scale = 0.0f,
23299 .type = TestOperandType::TENSOR_FLOAT32,
23300 .zeroPoint = 0
23301 }, { // param3
23302 .channelQuant = {},
23303 .data = TestBuffer::createFromVector<float>({1e-06f}),
23304 .dimensions = {},
23305 .isIgnored = false,
23306 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23307 .numberOfConsumers = 1,
23308 .scale = 0.0f,
23309 .type = TestOperandType::FLOAT32,
23310 .zeroPoint = 0
23311 }, { // axis
23312 .channelQuant = {},
23313 .data = TestBuffer::createFromVector<int32_t>({-1}),
23314 .dimensions = {},
23315 .isIgnored = false,
23316 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23317 .numberOfConsumers = 1,
23318 .scale = 0.0f,
23319 .type = TestOperandType::INT32,
23320 .zeroPoint = 0
23321 }, { // op2
23322 .channelQuant = {},
23323 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23324 .dimensions = {2, 5},
23325 .isIgnored = false,
23326 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23327 .numberOfConsumers = 0,
23328 .scale = 0.0f,
23329 .type = TestOperandType::TENSOR_FLOAT32,
23330 .zeroPoint = 0
23331 }, { // op1_new
23332 .channelQuant = {},
23333 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
23334 .dimensions = {2, 5},
23335 .isIgnored = false,
23336 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23337 .numberOfConsumers = 1,
23338 .scale = 0.0f,
23339 .type = TestOperandType::TENSOR_FLOAT32,
23340 .zeroPoint = 0
23341 }, { // placeholder141
23342 .channelQuant = {},
23343 .data = TestBuffer::createFromVector<float>({0.0f}),
23344 .dimensions = {1},
23345 .isIgnored = false,
23346 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23347 .numberOfConsumers = 1,
23348 .scale = 0.0f,
23349 .type = TestOperandType::TENSOR_FLOAT32,
23350 .zeroPoint = 0
23351 }, { // param159
23352 .channelQuant = {},
23353 .data = TestBuffer::createFromVector<int32_t>({0}),
23354 .dimensions = {},
23355 .isIgnored = false,
23356 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23357 .numberOfConsumers = 1,
23358 .scale = 0.0f,
23359 .type = TestOperandType::INT32,
23360 .zeroPoint = 0
23361 }},
23362 .operations = {{
23363 .inputs = {4, 5, 6},
23364 .outputs = {0},
23365 .type = TestOperationType::ADD
23366 }, {
23367 .inputs = {0, 1, 2},
23368 .outputs = {3},
23369 .type = TestOperationType::SOFTMAX
23370 }},
23371 .outputIndexes = {3}
23372 },
23373 .minSupportedVersion = TestHalVersion::UNKNOWN,
23374 .referenced = {}
23375 };
23376 return model;
23377 }
23378
23379 const auto dummy_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim2_axis1_neg_all_inputs_as_internal_2());
23380
23381 } // namespace generated_tests::softmax_v1_2
23382
23383 namespace generated_tests::softmax_v1_2 {
23384
get_test_model_axis_relaxed_dim1_axis0_2()23385 const TestModel& get_test_model_axis_relaxed_dim1_axis0_2() {
23386 static TestModel model = {
23387 .expectFailure = false,
23388 .expectedMultinomialDistributionTolerance = 0,
23389 .isRelaxed = true,
23390 .main = { // axis
23391 .inputIndexes = {0},
23392 .operands = {{ // op1
23393 .channelQuant = {},
23394 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
23395 .dimensions = {5},
23396 .isIgnored = false,
23397 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23398 .numberOfConsumers = 1,
23399 .scale = 0.0f,
23400 .type = TestOperandType::TENSOR_FLOAT32,
23401 .zeroPoint = 0
23402 }, { // param3
23403 .channelQuant = {},
23404 .data = TestBuffer::createFromVector<float>({1e-06f}),
23405 .dimensions = {},
23406 .isIgnored = false,
23407 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23408 .numberOfConsumers = 1,
23409 .scale = 0.0f,
23410 .type = TestOperandType::FLOAT32,
23411 .zeroPoint = 0
23412 }, { // axis
23413 .channelQuant = {},
23414 .data = TestBuffer::createFromVector<int32_t>({0}),
23415 .dimensions = {},
23416 .isIgnored = false,
23417 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23418 .numberOfConsumers = 1,
23419 .scale = 0.0f,
23420 .type = TestOperandType::INT32,
23421 .zeroPoint = 0
23422 }, { // op2
23423 .channelQuant = {},
23424 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23425 .dimensions = {5},
23426 .isIgnored = false,
23427 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23428 .numberOfConsumers = 0,
23429 .scale = 0.0f,
23430 .type = TestOperandType::TENSOR_FLOAT32,
23431 .zeroPoint = 0
23432 }},
23433 .operations = {{
23434 .inputs = {0, 1, 2},
23435 .outputs = {3},
23436 .type = TestOperationType::SOFTMAX
23437 }},
23438 .outputIndexes = {3}
23439 },
23440 .minSupportedVersion = TestHalVersion::UNKNOWN,
23441 .referenced = {}
23442 };
23443 return model;
23444 }
23445
23446 const auto dummy_test_model_axis_relaxed_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0_2", get_test_model_axis_relaxed_dim1_axis0_2());
23447
23448 } // namespace generated_tests::softmax_v1_2
23449
23450 namespace generated_tests::softmax_v1_2 {
23451
get_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal_2()23452 const TestModel& get_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal_2() {
23453 static TestModel model = {
23454 .expectFailure = false,
23455 .expectedMultinomialDistributionTolerance = 0,
23456 .isRelaxed = true,
23457 .main = { // axis
23458 .inputIndexes = {4},
23459 .operands = {{ // op1
23460 .channelQuant = {},
23461 .data = TestBuffer::createFromVector<float>({}),
23462 .dimensions = {5},
23463 .isIgnored = false,
23464 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
23465 .numberOfConsumers = 1,
23466 .scale = 0.0f,
23467 .type = TestOperandType::TENSOR_FLOAT32,
23468 .zeroPoint = 0
23469 }, { // param3
23470 .channelQuant = {},
23471 .data = TestBuffer::createFromVector<float>({1e-06f}),
23472 .dimensions = {},
23473 .isIgnored = false,
23474 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23475 .numberOfConsumers = 1,
23476 .scale = 0.0f,
23477 .type = TestOperandType::FLOAT32,
23478 .zeroPoint = 0
23479 }, { // axis
23480 .channelQuant = {},
23481 .data = TestBuffer::createFromVector<int32_t>({0}),
23482 .dimensions = {},
23483 .isIgnored = false,
23484 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23485 .numberOfConsumers = 1,
23486 .scale = 0.0f,
23487 .type = TestOperandType::INT32,
23488 .zeroPoint = 0
23489 }, { // op2
23490 .channelQuant = {},
23491 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23492 .dimensions = {5},
23493 .isIgnored = false,
23494 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23495 .numberOfConsumers = 0,
23496 .scale = 0.0f,
23497 .type = TestOperandType::TENSOR_FLOAT32,
23498 .zeroPoint = 0
23499 }, { // op1_new
23500 .channelQuant = {},
23501 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
23502 .dimensions = {5},
23503 .isIgnored = false,
23504 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23505 .numberOfConsumers = 1,
23506 .scale = 0.0f,
23507 .type = TestOperandType::TENSOR_FLOAT32,
23508 .zeroPoint = 0
23509 }, { // placeholder142
23510 .channelQuant = {},
23511 .data = TestBuffer::createFromVector<float>({0.0f}),
23512 .dimensions = {1},
23513 .isIgnored = false,
23514 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23515 .numberOfConsumers = 1,
23516 .scale = 0.0f,
23517 .type = TestOperandType::TENSOR_FLOAT32,
23518 .zeroPoint = 0
23519 }, { // param160
23520 .channelQuant = {},
23521 .data = TestBuffer::createFromVector<int32_t>({0}),
23522 .dimensions = {},
23523 .isIgnored = false,
23524 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23525 .numberOfConsumers = 1,
23526 .scale = 0.0f,
23527 .type = TestOperandType::INT32,
23528 .zeroPoint = 0
23529 }},
23530 .operations = {{
23531 .inputs = {4, 5, 6},
23532 .outputs = {0},
23533 .type = TestOperationType::ADD
23534 }, {
23535 .inputs = {0, 1, 2},
23536 .outputs = {3},
23537 .type = TestOperationType::SOFTMAX
23538 }},
23539 .outputIndexes = {3}
23540 },
23541 .minSupportedVersion = TestHalVersion::UNKNOWN,
23542 .referenced = {}
23543 };
23544 return model;
23545 }
23546
23547 const auto dummy_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim1_axis0_all_inputs_as_internal_2());
23548
23549 } // namespace generated_tests::softmax_v1_2
23550
23551 namespace generated_tests::softmax_v1_2 {
23552
get_test_model_axis_relaxed_dim1_axis0_neg_2()23553 const TestModel& get_test_model_axis_relaxed_dim1_axis0_neg_2() {
23554 static TestModel model = {
23555 .expectFailure = false,
23556 .expectedMultinomialDistributionTolerance = 0,
23557 .isRelaxed = true,
23558 .main = { // axis
23559 .inputIndexes = {0},
23560 .operands = {{ // op1
23561 .channelQuant = {},
23562 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
23563 .dimensions = {5},
23564 .isIgnored = false,
23565 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23566 .numberOfConsumers = 1,
23567 .scale = 0.0f,
23568 .type = TestOperandType::TENSOR_FLOAT32,
23569 .zeroPoint = 0
23570 }, { // param3
23571 .channelQuant = {},
23572 .data = TestBuffer::createFromVector<float>({1e-06f}),
23573 .dimensions = {},
23574 .isIgnored = false,
23575 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23576 .numberOfConsumers = 1,
23577 .scale = 0.0f,
23578 .type = TestOperandType::FLOAT32,
23579 .zeroPoint = 0
23580 }, { // axis
23581 .channelQuant = {},
23582 .data = TestBuffer::createFromVector<int32_t>({-1}),
23583 .dimensions = {},
23584 .isIgnored = false,
23585 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23586 .numberOfConsumers = 1,
23587 .scale = 0.0f,
23588 .type = TestOperandType::INT32,
23589 .zeroPoint = 0
23590 }, { // op2
23591 .channelQuant = {},
23592 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23593 .dimensions = {5},
23594 .isIgnored = false,
23595 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23596 .numberOfConsumers = 0,
23597 .scale = 0.0f,
23598 .type = TestOperandType::TENSOR_FLOAT32,
23599 .zeroPoint = 0
23600 }},
23601 .operations = {{
23602 .inputs = {0, 1, 2},
23603 .outputs = {3},
23604 .type = TestOperationType::SOFTMAX
23605 }},
23606 .outputIndexes = {3}
23607 },
23608 .minSupportedVersion = TestHalVersion::UNKNOWN,
23609 .referenced = {}
23610 };
23611 return model;
23612 }
23613
23614 const auto dummy_test_model_axis_relaxed_dim1_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0_neg_2", get_test_model_axis_relaxed_dim1_axis0_neg_2());
23615
23616 } // namespace generated_tests::softmax_v1_2
23617
23618 namespace generated_tests::softmax_v1_2 {
23619
get_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal_2()23620 const TestModel& get_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal_2() {
23621 static TestModel model = {
23622 .expectFailure = false,
23623 .expectedMultinomialDistributionTolerance = 0,
23624 .isRelaxed = true,
23625 .main = { // axis
23626 .inputIndexes = {4},
23627 .operands = {{ // op1
23628 .channelQuant = {},
23629 .data = TestBuffer::createFromVector<float>({}),
23630 .dimensions = {5},
23631 .isIgnored = false,
23632 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
23633 .numberOfConsumers = 1,
23634 .scale = 0.0f,
23635 .type = TestOperandType::TENSOR_FLOAT32,
23636 .zeroPoint = 0
23637 }, { // param3
23638 .channelQuant = {},
23639 .data = TestBuffer::createFromVector<float>({1e-06f}),
23640 .dimensions = {},
23641 .isIgnored = false,
23642 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23643 .numberOfConsumers = 1,
23644 .scale = 0.0f,
23645 .type = TestOperandType::FLOAT32,
23646 .zeroPoint = 0
23647 }, { // axis
23648 .channelQuant = {},
23649 .data = TestBuffer::createFromVector<int32_t>({-1}),
23650 .dimensions = {},
23651 .isIgnored = false,
23652 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23653 .numberOfConsumers = 1,
23654 .scale = 0.0f,
23655 .type = TestOperandType::INT32,
23656 .zeroPoint = 0
23657 }, { // op2
23658 .channelQuant = {},
23659 .data = TestBuffer::createFromVector<float>({0.2f, 0.2f, 0.2f, 0.2f, 0.2f}),
23660 .dimensions = {5},
23661 .isIgnored = false,
23662 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23663 .numberOfConsumers = 0,
23664 .scale = 0.0f,
23665 .type = TestOperandType::TENSOR_FLOAT32,
23666 .zeroPoint = 0
23667 }, { // op1_new
23668 .channelQuant = {},
23669 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
23670 .dimensions = {5},
23671 .isIgnored = false,
23672 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23673 .numberOfConsumers = 1,
23674 .scale = 0.0f,
23675 .type = TestOperandType::TENSOR_FLOAT32,
23676 .zeroPoint = 0
23677 }, { // placeholder143
23678 .channelQuant = {},
23679 .data = TestBuffer::createFromVector<float>({0.0f}),
23680 .dimensions = {1},
23681 .isIgnored = false,
23682 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23683 .numberOfConsumers = 1,
23684 .scale = 0.0f,
23685 .type = TestOperandType::TENSOR_FLOAT32,
23686 .zeroPoint = 0
23687 }, { // param161
23688 .channelQuant = {},
23689 .data = TestBuffer::createFromVector<int32_t>({0}),
23690 .dimensions = {},
23691 .isIgnored = false,
23692 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23693 .numberOfConsumers = 1,
23694 .scale = 0.0f,
23695 .type = TestOperandType::INT32,
23696 .zeroPoint = 0
23697 }},
23698 .operations = {{
23699 .inputs = {4, 5, 6},
23700 .outputs = {0},
23701 .type = TestOperationType::ADD
23702 }, {
23703 .inputs = {0, 1, 2},
23704 .outputs = {3},
23705 .type = TestOperationType::SOFTMAX
23706 }},
23707 .outputIndexes = {3}
23708 },
23709 .minSupportedVersion = TestHalVersion::UNKNOWN,
23710 .referenced = {}
23711 };
23712 return model;
23713 }
23714
23715 const auto dummy_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_relaxed_dim1_axis0_neg_all_inputs_as_internal_2());
23716
23717 } // namespace generated_tests::softmax_v1_2
23718
23719 namespace generated_tests::softmax_v1_2 {
23720
get_test_model_axis_float16_dim4_axis0_2()23721 const TestModel& get_test_model_axis_float16_dim4_axis0_2() {
23722 static TestModel model = {
23723 .expectFailure = false,
23724 .expectedMultinomialDistributionTolerance = 0,
23725 .isRelaxed = false,
23726 .main = { // axis
23727 .inputIndexes = {0},
23728 .operands = {{ // op1
23729 .channelQuant = {},
23730 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
23731 .dimensions = {5, 2, 2, 2},
23732 .isIgnored = false,
23733 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23734 .numberOfConsumers = 1,
23735 .scale = 0.0f,
23736 .type = TestOperandType::TENSOR_FLOAT16,
23737 .zeroPoint = 0
23738 }, { // param3
23739 .channelQuant = {},
23740 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
23741 .dimensions = {},
23742 .isIgnored = false,
23743 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23744 .numberOfConsumers = 1,
23745 .scale = 0.0f,
23746 .type = TestOperandType::FLOAT16,
23747 .zeroPoint = 0
23748 }, { // axis
23749 .channelQuant = {},
23750 .data = TestBuffer::createFromVector<int32_t>({0}),
23751 .dimensions = {},
23752 .isIgnored = false,
23753 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23754 .numberOfConsumers = 1,
23755 .scale = 0.0f,
23756 .type = TestOperandType::INT32,
23757 .zeroPoint = 0
23758 }, { // op2
23759 .channelQuant = {},
23760 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
23761 .dimensions = {5, 2, 2, 2},
23762 .isIgnored = false,
23763 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23764 .numberOfConsumers = 0,
23765 .scale = 0.0f,
23766 .type = TestOperandType::TENSOR_FLOAT16,
23767 .zeroPoint = 0
23768 }},
23769 .operations = {{
23770 .inputs = {0, 1, 2},
23771 .outputs = {3},
23772 .type = TestOperationType::SOFTMAX
23773 }},
23774 .outputIndexes = {3}
23775 },
23776 .minSupportedVersion = TestHalVersion::V1_2,
23777 .referenced = {}
23778 };
23779 return model;
23780 }
23781
23782 const auto dummy_test_model_axis_float16_dim4_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0_2", get_test_model_axis_float16_dim4_axis0_2());
23783
23784 } // namespace generated_tests::softmax_v1_2
23785
23786 namespace generated_tests::softmax_v1_2 {
23787
get_test_model_axis_float16_dim4_axis0_all_inputs_as_internal_2()23788 const TestModel& get_test_model_axis_float16_dim4_axis0_all_inputs_as_internal_2() {
23789 static TestModel model = {
23790 .expectFailure = false,
23791 .expectedMultinomialDistributionTolerance = 0,
23792 .isRelaxed = false,
23793 .main = { // axis
23794 .inputIndexes = {4},
23795 .operands = {{ // op1
23796 .channelQuant = {},
23797 .data = TestBuffer::createFromVector<_Float16>({}),
23798 .dimensions = {5, 2, 2, 2},
23799 .isIgnored = false,
23800 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
23801 .numberOfConsumers = 1,
23802 .scale = 0.0f,
23803 .type = TestOperandType::TENSOR_FLOAT16,
23804 .zeroPoint = 0
23805 }, { // param3
23806 .channelQuant = {},
23807 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
23808 .dimensions = {},
23809 .isIgnored = false,
23810 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23811 .numberOfConsumers = 1,
23812 .scale = 0.0f,
23813 .type = TestOperandType::FLOAT16,
23814 .zeroPoint = 0
23815 }, { // axis
23816 .channelQuant = {},
23817 .data = TestBuffer::createFromVector<int32_t>({0}),
23818 .dimensions = {},
23819 .isIgnored = false,
23820 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23821 .numberOfConsumers = 1,
23822 .scale = 0.0f,
23823 .type = TestOperandType::INT32,
23824 .zeroPoint = 0
23825 }, { // op2
23826 .channelQuant = {},
23827 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
23828 .dimensions = {5, 2, 2, 2},
23829 .isIgnored = false,
23830 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23831 .numberOfConsumers = 0,
23832 .scale = 0.0f,
23833 .type = TestOperandType::TENSOR_FLOAT16,
23834 .zeroPoint = 0
23835 }, { // op1_new
23836 .channelQuant = {},
23837 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
23838 .dimensions = {5, 2, 2, 2},
23839 .isIgnored = false,
23840 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23841 .numberOfConsumers = 1,
23842 .scale = 0.0f,
23843 .type = TestOperandType::TENSOR_FLOAT16,
23844 .zeroPoint = 0
23845 }, { // placeholder144
23846 .channelQuant = {},
23847 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
23848 .dimensions = {1},
23849 .isIgnored = false,
23850 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23851 .numberOfConsumers = 1,
23852 .scale = 0.0f,
23853 .type = TestOperandType::TENSOR_FLOAT16,
23854 .zeroPoint = 0
23855 }, { // param162
23856 .channelQuant = {},
23857 .data = TestBuffer::createFromVector<int32_t>({0}),
23858 .dimensions = {},
23859 .isIgnored = false,
23860 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23861 .numberOfConsumers = 1,
23862 .scale = 0.0f,
23863 .type = TestOperandType::INT32,
23864 .zeroPoint = 0
23865 }},
23866 .operations = {{
23867 .inputs = {4, 5, 6},
23868 .outputs = {0},
23869 .type = TestOperationType::ADD
23870 }, {
23871 .inputs = {0, 1, 2},
23872 .outputs = {3},
23873 .type = TestOperationType::SOFTMAX
23874 }},
23875 .outputIndexes = {3}
23876 },
23877 .minSupportedVersion = TestHalVersion::V1_2,
23878 .referenced = {}
23879 };
23880 return model;
23881 }
23882
23883 const auto dummy_test_model_axis_float16_dim4_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis0_all_inputs_as_internal_2());
23884
23885 } // namespace generated_tests::softmax_v1_2
23886
23887 namespace generated_tests::softmax_v1_2 {
23888
get_test_model_axis_float16_dim4_axis0_neg_2()23889 const TestModel& get_test_model_axis_float16_dim4_axis0_neg_2() {
23890 static TestModel model = {
23891 .expectFailure = false,
23892 .expectedMultinomialDistributionTolerance = 0,
23893 .isRelaxed = false,
23894 .main = { // axis
23895 .inputIndexes = {0},
23896 .operands = {{ // op1
23897 .channelQuant = {},
23898 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
23899 .dimensions = {5, 2, 2, 2},
23900 .isIgnored = false,
23901 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
23902 .numberOfConsumers = 1,
23903 .scale = 0.0f,
23904 .type = TestOperandType::TENSOR_FLOAT16,
23905 .zeroPoint = 0
23906 }, { // param3
23907 .channelQuant = {},
23908 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
23909 .dimensions = {},
23910 .isIgnored = false,
23911 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23912 .numberOfConsumers = 1,
23913 .scale = 0.0f,
23914 .type = TestOperandType::FLOAT16,
23915 .zeroPoint = 0
23916 }, { // axis
23917 .channelQuant = {},
23918 .data = TestBuffer::createFromVector<int32_t>({-4}),
23919 .dimensions = {},
23920 .isIgnored = false,
23921 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23922 .numberOfConsumers = 1,
23923 .scale = 0.0f,
23924 .type = TestOperandType::INT32,
23925 .zeroPoint = 0
23926 }, { // op2
23927 .channelQuant = {},
23928 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
23929 .dimensions = {5, 2, 2, 2},
23930 .isIgnored = false,
23931 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23932 .numberOfConsumers = 0,
23933 .scale = 0.0f,
23934 .type = TestOperandType::TENSOR_FLOAT16,
23935 .zeroPoint = 0
23936 }},
23937 .operations = {{
23938 .inputs = {0, 1, 2},
23939 .outputs = {3},
23940 .type = TestOperationType::SOFTMAX
23941 }},
23942 .outputIndexes = {3}
23943 },
23944 .minSupportedVersion = TestHalVersion::V1_2,
23945 .referenced = {}
23946 };
23947 return model;
23948 }
23949
23950 const auto dummy_test_model_axis_float16_dim4_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0_neg_2", get_test_model_axis_float16_dim4_axis0_neg_2());
23951
23952 } // namespace generated_tests::softmax_v1_2
23953
23954 namespace generated_tests::softmax_v1_2 {
23955
get_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal_2()23956 const TestModel& get_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal_2() {
23957 static TestModel model = {
23958 .expectFailure = false,
23959 .expectedMultinomialDistributionTolerance = 0,
23960 .isRelaxed = false,
23961 .main = { // axis
23962 .inputIndexes = {4},
23963 .operands = {{ // op1
23964 .channelQuant = {},
23965 .data = TestBuffer::createFromVector<_Float16>({}),
23966 .dimensions = {5, 2, 2, 2},
23967 .isIgnored = false,
23968 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
23969 .numberOfConsumers = 1,
23970 .scale = 0.0f,
23971 .type = TestOperandType::TENSOR_FLOAT16,
23972 .zeroPoint = 0
23973 }, { // param3
23974 .channelQuant = {},
23975 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
23976 .dimensions = {},
23977 .isIgnored = false,
23978 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23979 .numberOfConsumers = 1,
23980 .scale = 0.0f,
23981 .type = TestOperandType::FLOAT16,
23982 .zeroPoint = 0
23983 }, { // axis
23984 .channelQuant = {},
23985 .data = TestBuffer::createFromVector<int32_t>({-4}),
23986 .dimensions = {},
23987 .isIgnored = false,
23988 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
23989 .numberOfConsumers = 1,
23990 .scale = 0.0f,
23991 .type = TestOperandType::INT32,
23992 .zeroPoint = 0
23993 }, { // op2
23994 .channelQuant = {},
23995 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
23996 .dimensions = {5, 2, 2, 2},
23997 .isIgnored = false,
23998 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
23999 .numberOfConsumers = 0,
24000 .scale = 0.0f,
24001 .type = TestOperandType::TENSOR_FLOAT16,
24002 .zeroPoint = 0
24003 }, { // op1_new
24004 .channelQuant = {},
24005 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
24006 .dimensions = {5, 2, 2, 2},
24007 .isIgnored = false,
24008 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24009 .numberOfConsumers = 1,
24010 .scale = 0.0f,
24011 .type = TestOperandType::TENSOR_FLOAT16,
24012 .zeroPoint = 0
24013 }, { // placeholder145
24014 .channelQuant = {},
24015 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
24016 .dimensions = {1},
24017 .isIgnored = false,
24018 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24019 .numberOfConsumers = 1,
24020 .scale = 0.0f,
24021 .type = TestOperandType::TENSOR_FLOAT16,
24022 .zeroPoint = 0
24023 }, { // param163
24024 .channelQuant = {},
24025 .data = TestBuffer::createFromVector<int32_t>({0}),
24026 .dimensions = {},
24027 .isIgnored = false,
24028 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24029 .numberOfConsumers = 1,
24030 .scale = 0.0f,
24031 .type = TestOperandType::INT32,
24032 .zeroPoint = 0
24033 }},
24034 .operations = {{
24035 .inputs = {4, 5, 6},
24036 .outputs = {0},
24037 .type = TestOperationType::ADD
24038 }, {
24039 .inputs = {0, 1, 2},
24040 .outputs = {3},
24041 .type = TestOperationType::SOFTMAX
24042 }},
24043 .outputIndexes = {3}
24044 },
24045 .minSupportedVersion = TestHalVersion::V1_2,
24046 .referenced = {}
24047 };
24048 return model;
24049 }
24050
24051 const auto dummy_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis0_neg_all_inputs_as_internal_2());
24052
24053 } // namespace generated_tests::softmax_v1_2
24054
24055 namespace generated_tests::softmax_v1_2 {
24056
get_test_model_axis_float16_dim4_axis1_2()24057 const TestModel& get_test_model_axis_float16_dim4_axis1_2() {
24058 static TestModel model = {
24059 .expectFailure = false,
24060 .expectedMultinomialDistributionTolerance = 0,
24061 .isRelaxed = false,
24062 .main = { // axis
24063 .inputIndexes = {0},
24064 .operands = {{ // op1
24065 .channelQuant = {},
24066 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
24067 .dimensions = {2, 5, 2, 2},
24068 .isIgnored = false,
24069 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24070 .numberOfConsumers = 1,
24071 .scale = 0.0f,
24072 .type = TestOperandType::TENSOR_FLOAT16,
24073 .zeroPoint = 0
24074 }, { // param3
24075 .channelQuant = {},
24076 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24077 .dimensions = {},
24078 .isIgnored = false,
24079 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24080 .numberOfConsumers = 1,
24081 .scale = 0.0f,
24082 .type = TestOperandType::FLOAT16,
24083 .zeroPoint = 0
24084 }, { // axis
24085 .channelQuant = {},
24086 .data = TestBuffer::createFromVector<int32_t>({1}),
24087 .dimensions = {},
24088 .isIgnored = false,
24089 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24090 .numberOfConsumers = 1,
24091 .scale = 0.0f,
24092 .type = TestOperandType::INT32,
24093 .zeroPoint = 0
24094 }, { // op2
24095 .channelQuant = {},
24096 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24097 .dimensions = {2, 5, 2, 2},
24098 .isIgnored = false,
24099 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24100 .numberOfConsumers = 0,
24101 .scale = 0.0f,
24102 .type = TestOperandType::TENSOR_FLOAT16,
24103 .zeroPoint = 0
24104 }},
24105 .operations = {{
24106 .inputs = {0, 1, 2},
24107 .outputs = {3},
24108 .type = TestOperationType::SOFTMAX
24109 }},
24110 .outputIndexes = {3}
24111 },
24112 .minSupportedVersion = TestHalVersion::V1_2,
24113 .referenced = {}
24114 };
24115 return model;
24116 }
24117
24118 const auto dummy_test_model_axis_float16_dim4_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1_2", get_test_model_axis_float16_dim4_axis1_2());
24119
24120 } // namespace generated_tests::softmax_v1_2
24121
24122 namespace generated_tests::softmax_v1_2 {
24123
get_test_model_axis_float16_dim4_axis1_all_inputs_as_internal_2()24124 const TestModel& get_test_model_axis_float16_dim4_axis1_all_inputs_as_internal_2() {
24125 static TestModel model = {
24126 .expectFailure = false,
24127 .expectedMultinomialDistributionTolerance = 0,
24128 .isRelaxed = false,
24129 .main = { // axis
24130 .inputIndexes = {4},
24131 .operands = {{ // op1
24132 .channelQuant = {},
24133 .data = TestBuffer::createFromVector<_Float16>({}),
24134 .dimensions = {2, 5, 2, 2},
24135 .isIgnored = false,
24136 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
24137 .numberOfConsumers = 1,
24138 .scale = 0.0f,
24139 .type = TestOperandType::TENSOR_FLOAT16,
24140 .zeroPoint = 0
24141 }, { // param3
24142 .channelQuant = {},
24143 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24144 .dimensions = {},
24145 .isIgnored = false,
24146 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24147 .numberOfConsumers = 1,
24148 .scale = 0.0f,
24149 .type = TestOperandType::FLOAT16,
24150 .zeroPoint = 0
24151 }, { // axis
24152 .channelQuant = {},
24153 .data = TestBuffer::createFromVector<int32_t>({1}),
24154 .dimensions = {},
24155 .isIgnored = false,
24156 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24157 .numberOfConsumers = 1,
24158 .scale = 0.0f,
24159 .type = TestOperandType::INT32,
24160 .zeroPoint = 0
24161 }, { // op2
24162 .channelQuant = {},
24163 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24164 .dimensions = {2, 5, 2, 2},
24165 .isIgnored = false,
24166 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24167 .numberOfConsumers = 0,
24168 .scale = 0.0f,
24169 .type = TestOperandType::TENSOR_FLOAT16,
24170 .zeroPoint = 0
24171 }, { // op1_new
24172 .channelQuant = {},
24173 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
24174 .dimensions = {2, 5, 2, 2},
24175 .isIgnored = false,
24176 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24177 .numberOfConsumers = 1,
24178 .scale = 0.0f,
24179 .type = TestOperandType::TENSOR_FLOAT16,
24180 .zeroPoint = 0
24181 }, { // placeholder146
24182 .channelQuant = {},
24183 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
24184 .dimensions = {1},
24185 .isIgnored = false,
24186 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24187 .numberOfConsumers = 1,
24188 .scale = 0.0f,
24189 .type = TestOperandType::TENSOR_FLOAT16,
24190 .zeroPoint = 0
24191 }, { // param164
24192 .channelQuant = {},
24193 .data = TestBuffer::createFromVector<int32_t>({0}),
24194 .dimensions = {},
24195 .isIgnored = false,
24196 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24197 .numberOfConsumers = 1,
24198 .scale = 0.0f,
24199 .type = TestOperandType::INT32,
24200 .zeroPoint = 0
24201 }},
24202 .operations = {{
24203 .inputs = {4, 5, 6},
24204 .outputs = {0},
24205 .type = TestOperationType::ADD
24206 }, {
24207 .inputs = {0, 1, 2},
24208 .outputs = {3},
24209 .type = TestOperationType::SOFTMAX
24210 }},
24211 .outputIndexes = {3}
24212 },
24213 .minSupportedVersion = TestHalVersion::V1_2,
24214 .referenced = {}
24215 };
24216 return model;
24217 }
24218
24219 const auto dummy_test_model_axis_float16_dim4_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis1_all_inputs_as_internal_2());
24220
24221 } // namespace generated_tests::softmax_v1_2
24222
24223 namespace generated_tests::softmax_v1_2 {
24224
get_test_model_axis_float16_dim4_axis1_neg_2()24225 const TestModel& get_test_model_axis_float16_dim4_axis1_neg_2() {
24226 static TestModel model = {
24227 .expectFailure = false,
24228 .expectedMultinomialDistributionTolerance = 0,
24229 .isRelaxed = false,
24230 .main = { // axis
24231 .inputIndexes = {0},
24232 .operands = {{ // op1
24233 .channelQuant = {},
24234 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
24235 .dimensions = {2, 5, 2, 2},
24236 .isIgnored = false,
24237 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24238 .numberOfConsumers = 1,
24239 .scale = 0.0f,
24240 .type = TestOperandType::TENSOR_FLOAT16,
24241 .zeroPoint = 0
24242 }, { // param3
24243 .channelQuant = {},
24244 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24245 .dimensions = {},
24246 .isIgnored = false,
24247 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24248 .numberOfConsumers = 1,
24249 .scale = 0.0f,
24250 .type = TestOperandType::FLOAT16,
24251 .zeroPoint = 0
24252 }, { // axis
24253 .channelQuant = {},
24254 .data = TestBuffer::createFromVector<int32_t>({-3}),
24255 .dimensions = {},
24256 .isIgnored = false,
24257 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24258 .numberOfConsumers = 1,
24259 .scale = 0.0f,
24260 .type = TestOperandType::INT32,
24261 .zeroPoint = 0
24262 }, { // op2
24263 .channelQuant = {},
24264 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24265 .dimensions = {2, 5, 2, 2},
24266 .isIgnored = false,
24267 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24268 .numberOfConsumers = 0,
24269 .scale = 0.0f,
24270 .type = TestOperandType::TENSOR_FLOAT16,
24271 .zeroPoint = 0
24272 }},
24273 .operations = {{
24274 .inputs = {0, 1, 2},
24275 .outputs = {3},
24276 .type = TestOperationType::SOFTMAX
24277 }},
24278 .outputIndexes = {3}
24279 },
24280 .minSupportedVersion = TestHalVersion::V1_2,
24281 .referenced = {}
24282 };
24283 return model;
24284 }
24285
24286 const auto dummy_test_model_axis_float16_dim4_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1_neg_2", get_test_model_axis_float16_dim4_axis1_neg_2());
24287
24288 } // namespace generated_tests::softmax_v1_2
24289
24290 namespace generated_tests::softmax_v1_2 {
24291
get_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal_2()24292 const TestModel& get_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal_2() {
24293 static TestModel model = {
24294 .expectFailure = false,
24295 .expectedMultinomialDistributionTolerance = 0,
24296 .isRelaxed = false,
24297 .main = { // axis
24298 .inputIndexes = {4},
24299 .operands = {{ // op1
24300 .channelQuant = {},
24301 .data = TestBuffer::createFromVector<_Float16>({}),
24302 .dimensions = {2, 5, 2, 2},
24303 .isIgnored = false,
24304 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
24305 .numberOfConsumers = 1,
24306 .scale = 0.0f,
24307 .type = TestOperandType::TENSOR_FLOAT16,
24308 .zeroPoint = 0
24309 }, { // param3
24310 .channelQuant = {},
24311 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24312 .dimensions = {},
24313 .isIgnored = false,
24314 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24315 .numberOfConsumers = 1,
24316 .scale = 0.0f,
24317 .type = TestOperandType::FLOAT16,
24318 .zeroPoint = 0
24319 }, { // axis
24320 .channelQuant = {},
24321 .data = TestBuffer::createFromVector<int32_t>({-3}),
24322 .dimensions = {},
24323 .isIgnored = false,
24324 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24325 .numberOfConsumers = 1,
24326 .scale = 0.0f,
24327 .type = TestOperandType::INT32,
24328 .zeroPoint = 0
24329 }, { // op2
24330 .channelQuant = {},
24331 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24332 .dimensions = {2, 5, 2, 2},
24333 .isIgnored = false,
24334 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24335 .numberOfConsumers = 0,
24336 .scale = 0.0f,
24337 .type = TestOperandType::TENSOR_FLOAT16,
24338 .zeroPoint = 0
24339 }, { // op1_new
24340 .channelQuant = {},
24341 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f, 1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
24342 .dimensions = {2, 5, 2, 2},
24343 .isIgnored = false,
24344 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24345 .numberOfConsumers = 1,
24346 .scale = 0.0f,
24347 .type = TestOperandType::TENSOR_FLOAT16,
24348 .zeroPoint = 0
24349 }, { // placeholder147
24350 .channelQuant = {},
24351 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
24352 .dimensions = {1},
24353 .isIgnored = false,
24354 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24355 .numberOfConsumers = 1,
24356 .scale = 0.0f,
24357 .type = TestOperandType::TENSOR_FLOAT16,
24358 .zeroPoint = 0
24359 }, { // param165
24360 .channelQuant = {},
24361 .data = TestBuffer::createFromVector<int32_t>({0}),
24362 .dimensions = {},
24363 .isIgnored = false,
24364 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24365 .numberOfConsumers = 1,
24366 .scale = 0.0f,
24367 .type = TestOperandType::INT32,
24368 .zeroPoint = 0
24369 }},
24370 .operations = {{
24371 .inputs = {4, 5, 6},
24372 .outputs = {0},
24373 .type = TestOperationType::ADD
24374 }, {
24375 .inputs = {0, 1, 2},
24376 .outputs = {3},
24377 .type = TestOperationType::SOFTMAX
24378 }},
24379 .outputIndexes = {3}
24380 },
24381 .minSupportedVersion = TestHalVersion::V1_2,
24382 .referenced = {}
24383 };
24384 return model;
24385 }
24386
24387 const auto dummy_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis1_neg_all_inputs_as_internal_2());
24388
24389 } // namespace generated_tests::softmax_v1_2
24390
24391 namespace generated_tests::softmax_v1_2 {
24392
get_test_model_axis_float16_dim4_axis2_2()24393 const TestModel& get_test_model_axis_float16_dim4_axis2_2() {
24394 static TestModel model = {
24395 .expectFailure = false,
24396 .expectedMultinomialDistributionTolerance = 0,
24397 .isRelaxed = false,
24398 .main = { // axis
24399 .inputIndexes = {0},
24400 .operands = {{ // op1
24401 .channelQuant = {},
24402 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
24403 .dimensions = {2, 2, 5, 2},
24404 .isIgnored = false,
24405 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24406 .numberOfConsumers = 1,
24407 .scale = 0.0f,
24408 .type = TestOperandType::TENSOR_FLOAT16,
24409 .zeroPoint = 0
24410 }, { // param3
24411 .channelQuant = {},
24412 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24413 .dimensions = {},
24414 .isIgnored = false,
24415 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24416 .numberOfConsumers = 1,
24417 .scale = 0.0f,
24418 .type = TestOperandType::FLOAT16,
24419 .zeroPoint = 0
24420 }, { // axis
24421 .channelQuant = {},
24422 .data = TestBuffer::createFromVector<int32_t>({2}),
24423 .dimensions = {},
24424 .isIgnored = false,
24425 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24426 .numberOfConsumers = 1,
24427 .scale = 0.0f,
24428 .type = TestOperandType::INT32,
24429 .zeroPoint = 0
24430 }, { // op2
24431 .channelQuant = {},
24432 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24433 .dimensions = {2, 2, 5, 2},
24434 .isIgnored = false,
24435 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24436 .numberOfConsumers = 0,
24437 .scale = 0.0f,
24438 .type = TestOperandType::TENSOR_FLOAT16,
24439 .zeroPoint = 0
24440 }},
24441 .operations = {{
24442 .inputs = {0, 1, 2},
24443 .outputs = {3},
24444 .type = TestOperationType::SOFTMAX
24445 }},
24446 .outputIndexes = {3}
24447 },
24448 .minSupportedVersion = TestHalVersion::V1_2,
24449 .referenced = {}
24450 };
24451 return model;
24452 }
24453
24454 const auto dummy_test_model_axis_float16_dim4_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2_2", get_test_model_axis_float16_dim4_axis2_2());
24455
24456 } // namespace generated_tests::softmax_v1_2
24457
24458 namespace generated_tests::softmax_v1_2 {
24459
get_test_model_axis_float16_dim4_axis2_all_inputs_as_internal_2()24460 const TestModel& get_test_model_axis_float16_dim4_axis2_all_inputs_as_internal_2() {
24461 static TestModel model = {
24462 .expectFailure = false,
24463 .expectedMultinomialDistributionTolerance = 0,
24464 .isRelaxed = false,
24465 .main = { // axis
24466 .inputIndexes = {4},
24467 .operands = {{ // op1
24468 .channelQuant = {},
24469 .data = TestBuffer::createFromVector<_Float16>({}),
24470 .dimensions = {2, 2, 5, 2},
24471 .isIgnored = false,
24472 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
24473 .numberOfConsumers = 1,
24474 .scale = 0.0f,
24475 .type = TestOperandType::TENSOR_FLOAT16,
24476 .zeroPoint = 0
24477 }, { // param3
24478 .channelQuant = {},
24479 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24480 .dimensions = {},
24481 .isIgnored = false,
24482 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24483 .numberOfConsumers = 1,
24484 .scale = 0.0f,
24485 .type = TestOperandType::FLOAT16,
24486 .zeroPoint = 0
24487 }, { // axis
24488 .channelQuant = {},
24489 .data = TestBuffer::createFromVector<int32_t>({2}),
24490 .dimensions = {},
24491 .isIgnored = false,
24492 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24493 .numberOfConsumers = 1,
24494 .scale = 0.0f,
24495 .type = TestOperandType::INT32,
24496 .zeroPoint = 0
24497 }, { // op2
24498 .channelQuant = {},
24499 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24500 .dimensions = {2, 2, 5, 2},
24501 .isIgnored = false,
24502 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24503 .numberOfConsumers = 0,
24504 .scale = 0.0f,
24505 .type = TestOperandType::TENSOR_FLOAT16,
24506 .zeroPoint = 0
24507 }, { // op1_new
24508 .channelQuant = {},
24509 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
24510 .dimensions = {2, 2, 5, 2},
24511 .isIgnored = false,
24512 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24513 .numberOfConsumers = 1,
24514 .scale = 0.0f,
24515 .type = TestOperandType::TENSOR_FLOAT16,
24516 .zeroPoint = 0
24517 }, { // placeholder148
24518 .channelQuant = {},
24519 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
24520 .dimensions = {1},
24521 .isIgnored = false,
24522 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24523 .numberOfConsumers = 1,
24524 .scale = 0.0f,
24525 .type = TestOperandType::TENSOR_FLOAT16,
24526 .zeroPoint = 0
24527 }, { // param166
24528 .channelQuant = {},
24529 .data = TestBuffer::createFromVector<int32_t>({0}),
24530 .dimensions = {},
24531 .isIgnored = false,
24532 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24533 .numberOfConsumers = 1,
24534 .scale = 0.0f,
24535 .type = TestOperandType::INT32,
24536 .zeroPoint = 0
24537 }},
24538 .operations = {{
24539 .inputs = {4, 5, 6},
24540 .outputs = {0},
24541 .type = TestOperationType::ADD
24542 }, {
24543 .inputs = {0, 1, 2},
24544 .outputs = {3},
24545 .type = TestOperationType::SOFTMAX
24546 }},
24547 .outputIndexes = {3}
24548 },
24549 .minSupportedVersion = TestHalVersion::V1_2,
24550 .referenced = {}
24551 };
24552 return model;
24553 }
24554
24555 const auto dummy_test_model_axis_float16_dim4_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis2_all_inputs_as_internal_2());
24556
24557 } // namespace generated_tests::softmax_v1_2
24558
24559 namespace generated_tests::softmax_v1_2 {
24560
get_test_model_axis_float16_dim4_axis2_neg_2()24561 const TestModel& get_test_model_axis_float16_dim4_axis2_neg_2() {
24562 static TestModel model = {
24563 .expectFailure = false,
24564 .expectedMultinomialDistributionTolerance = 0,
24565 .isRelaxed = false,
24566 .main = { // axis
24567 .inputIndexes = {0},
24568 .operands = {{ // op1
24569 .channelQuant = {},
24570 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
24571 .dimensions = {2, 2, 5, 2},
24572 .isIgnored = false,
24573 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24574 .numberOfConsumers = 1,
24575 .scale = 0.0f,
24576 .type = TestOperandType::TENSOR_FLOAT16,
24577 .zeroPoint = 0
24578 }, { // param3
24579 .channelQuant = {},
24580 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24581 .dimensions = {},
24582 .isIgnored = false,
24583 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24584 .numberOfConsumers = 1,
24585 .scale = 0.0f,
24586 .type = TestOperandType::FLOAT16,
24587 .zeroPoint = 0
24588 }, { // axis
24589 .channelQuant = {},
24590 .data = TestBuffer::createFromVector<int32_t>({-2}),
24591 .dimensions = {},
24592 .isIgnored = false,
24593 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24594 .numberOfConsumers = 1,
24595 .scale = 0.0f,
24596 .type = TestOperandType::INT32,
24597 .zeroPoint = 0
24598 }, { // op2
24599 .channelQuant = {},
24600 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24601 .dimensions = {2, 2, 5, 2},
24602 .isIgnored = false,
24603 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24604 .numberOfConsumers = 0,
24605 .scale = 0.0f,
24606 .type = TestOperandType::TENSOR_FLOAT16,
24607 .zeroPoint = 0
24608 }},
24609 .operations = {{
24610 .inputs = {0, 1, 2},
24611 .outputs = {3},
24612 .type = TestOperationType::SOFTMAX
24613 }},
24614 .outputIndexes = {3}
24615 },
24616 .minSupportedVersion = TestHalVersion::V1_2,
24617 .referenced = {}
24618 };
24619 return model;
24620 }
24621
24622 const auto dummy_test_model_axis_float16_dim4_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2_neg_2", get_test_model_axis_float16_dim4_axis2_neg_2());
24623
24624 } // namespace generated_tests::softmax_v1_2
24625
24626 namespace generated_tests::softmax_v1_2 {
24627
get_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal_2()24628 const TestModel& get_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal_2() {
24629 static TestModel model = {
24630 .expectFailure = false,
24631 .expectedMultinomialDistributionTolerance = 0,
24632 .isRelaxed = false,
24633 .main = { // axis
24634 .inputIndexes = {4},
24635 .operands = {{ // op1
24636 .channelQuant = {},
24637 .data = TestBuffer::createFromVector<_Float16>({}),
24638 .dimensions = {2, 2, 5, 2},
24639 .isIgnored = false,
24640 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
24641 .numberOfConsumers = 1,
24642 .scale = 0.0f,
24643 .type = TestOperandType::TENSOR_FLOAT16,
24644 .zeroPoint = 0
24645 }, { // param3
24646 .channelQuant = {},
24647 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24648 .dimensions = {},
24649 .isIgnored = false,
24650 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24651 .numberOfConsumers = 1,
24652 .scale = 0.0f,
24653 .type = TestOperandType::FLOAT16,
24654 .zeroPoint = 0
24655 }, { // axis
24656 .channelQuant = {},
24657 .data = TestBuffer::createFromVector<int32_t>({-2}),
24658 .dimensions = {},
24659 .isIgnored = false,
24660 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24661 .numberOfConsumers = 1,
24662 .scale = 0.0f,
24663 .type = TestOperandType::INT32,
24664 .zeroPoint = 0
24665 }, { // op2
24666 .channelQuant = {},
24667 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24668 .dimensions = {2, 2, 5, 2},
24669 .isIgnored = false,
24670 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24671 .numberOfConsumers = 0,
24672 .scale = 0.0f,
24673 .type = TestOperandType::TENSOR_FLOAT16,
24674 .zeroPoint = 0
24675 }, { // op1_new
24676 .channelQuant = {},
24677 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
24678 .dimensions = {2, 2, 5, 2},
24679 .isIgnored = false,
24680 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24681 .numberOfConsumers = 1,
24682 .scale = 0.0f,
24683 .type = TestOperandType::TENSOR_FLOAT16,
24684 .zeroPoint = 0
24685 }, { // placeholder149
24686 .channelQuant = {},
24687 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
24688 .dimensions = {1},
24689 .isIgnored = false,
24690 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24691 .numberOfConsumers = 1,
24692 .scale = 0.0f,
24693 .type = TestOperandType::TENSOR_FLOAT16,
24694 .zeroPoint = 0
24695 }, { // param167
24696 .channelQuant = {},
24697 .data = TestBuffer::createFromVector<int32_t>({0}),
24698 .dimensions = {},
24699 .isIgnored = false,
24700 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24701 .numberOfConsumers = 1,
24702 .scale = 0.0f,
24703 .type = TestOperandType::INT32,
24704 .zeroPoint = 0
24705 }},
24706 .operations = {{
24707 .inputs = {4, 5, 6},
24708 .outputs = {0},
24709 .type = TestOperationType::ADD
24710 }, {
24711 .inputs = {0, 1, 2},
24712 .outputs = {3},
24713 .type = TestOperationType::SOFTMAX
24714 }},
24715 .outputIndexes = {3}
24716 },
24717 .minSupportedVersion = TestHalVersion::V1_2,
24718 .referenced = {}
24719 };
24720 return model;
24721 }
24722
24723 const auto dummy_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis2_neg_all_inputs_as_internal_2());
24724
24725 } // namespace generated_tests::softmax_v1_2
24726
24727 namespace generated_tests::softmax_v1_2 {
24728
get_test_model_axis_float16_dim4_axis3_2()24729 const TestModel& get_test_model_axis_float16_dim4_axis3_2() {
24730 static TestModel model = {
24731 .expectFailure = false,
24732 .expectedMultinomialDistributionTolerance = 0,
24733 .isRelaxed = false,
24734 .main = { // axis
24735 .inputIndexes = {0},
24736 .operands = {{ // op1
24737 .channelQuant = {},
24738 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
24739 .dimensions = {2, 2, 2, 5},
24740 .isIgnored = false,
24741 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24742 .numberOfConsumers = 1,
24743 .scale = 0.0f,
24744 .type = TestOperandType::TENSOR_FLOAT16,
24745 .zeroPoint = 0
24746 }, { // param3
24747 .channelQuant = {},
24748 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24749 .dimensions = {},
24750 .isIgnored = false,
24751 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24752 .numberOfConsumers = 1,
24753 .scale = 0.0f,
24754 .type = TestOperandType::FLOAT16,
24755 .zeroPoint = 0
24756 }, { // axis
24757 .channelQuant = {},
24758 .data = TestBuffer::createFromVector<int32_t>({3}),
24759 .dimensions = {},
24760 .isIgnored = false,
24761 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24762 .numberOfConsumers = 1,
24763 .scale = 0.0f,
24764 .type = TestOperandType::INT32,
24765 .zeroPoint = 0
24766 }, { // op2
24767 .channelQuant = {},
24768 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24769 .dimensions = {2, 2, 2, 5},
24770 .isIgnored = false,
24771 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24772 .numberOfConsumers = 0,
24773 .scale = 0.0f,
24774 .type = TestOperandType::TENSOR_FLOAT16,
24775 .zeroPoint = 0
24776 }},
24777 .operations = {{
24778 .inputs = {0, 1, 2},
24779 .outputs = {3},
24780 .type = TestOperationType::SOFTMAX
24781 }},
24782 .outputIndexes = {3}
24783 },
24784 .minSupportedVersion = TestHalVersion::V1_2,
24785 .referenced = {}
24786 };
24787 return model;
24788 }
24789
24790 const auto dummy_test_model_axis_float16_dim4_axis3_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3_2", get_test_model_axis_float16_dim4_axis3_2());
24791
24792 } // namespace generated_tests::softmax_v1_2
24793
24794 namespace generated_tests::softmax_v1_2 {
24795
get_test_model_axis_float16_dim4_axis3_all_inputs_as_internal_2()24796 const TestModel& get_test_model_axis_float16_dim4_axis3_all_inputs_as_internal_2() {
24797 static TestModel model = {
24798 .expectFailure = false,
24799 .expectedMultinomialDistributionTolerance = 0,
24800 .isRelaxed = false,
24801 .main = { // axis
24802 .inputIndexes = {4},
24803 .operands = {{ // op1
24804 .channelQuant = {},
24805 .data = TestBuffer::createFromVector<_Float16>({}),
24806 .dimensions = {2, 2, 2, 5},
24807 .isIgnored = false,
24808 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
24809 .numberOfConsumers = 1,
24810 .scale = 0.0f,
24811 .type = TestOperandType::TENSOR_FLOAT16,
24812 .zeroPoint = 0
24813 }, { // param3
24814 .channelQuant = {},
24815 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24816 .dimensions = {},
24817 .isIgnored = false,
24818 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24819 .numberOfConsumers = 1,
24820 .scale = 0.0f,
24821 .type = TestOperandType::FLOAT16,
24822 .zeroPoint = 0
24823 }, { // axis
24824 .channelQuant = {},
24825 .data = TestBuffer::createFromVector<int32_t>({3}),
24826 .dimensions = {},
24827 .isIgnored = false,
24828 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24829 .numberOfConsumers = 1,
24830 .scale = 0.0f,
24831 .type = TestOperandType::INT32,
24832 .zeroPoint = 0
24833 }, { // op2
24834 .channelQuant = {},
24835 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24836 .dimensions = {2, 2, 2, 5},
24837 .isIgnored = false,
24838 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24839 .numberOfConsumers = 0,
24840 .scale = 0.0f,
24841 .type = TestOperandType::TENSOR_FLOAT16,
24842 .zeroPoint = 0
24843 }, { // op1_new
24844 .channelQuant = {},
24845 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
24846 .dimensions = {2, 2, 2, 5},
24847 .isIgnored = false,
24848 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24849 .numberOfConsumers = 1,
24850 .scale = 0.0f,
24851 .type = TestOperandType::TENSOR_FLOAT16,
24852 .zeroPoint = 0
24853 }, { // placeholder150
24854 .channelQuant = {},
24855 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
24856 .dimensions = {1},
24857 .isIgnored = false,
24858 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24859 .numberOfConsumers = 1,
24860 .scale = 0.0f,
24861 .type = TestOperandType::TENSOR_FLOAT16,
24862 .zeroPoint = 0
24863 }, { // param168
24864 .channelQuant = {},
24865 .data = TestBuffer::createFromVector<int32_t>({0}),
24866 .dimensions = {},
24867 .isIgnored = false,
24868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24869 .numberOfConsumers = 1,
24870 .scale = 0.0f,
24871 .type = TestOperandType::INT32,
24872 .zeroPoint = 0
24873 }},
24874 .operations = {{
24875 .inputs = {4, 5, 6},
24876 .outputs = {0},
24877 .type = TestOperationType::ADD
24878 }, {
24879 .inputs = {0, 1, 2},
24880 .outputs = {3},
24881 .type = TestOperationType::SOFTMAX
24882 }},
24883 .outputIndexes = {3}
24884 },
24885 .minSupportedVersion = TestHalVersion::V1_2,
24886 .referenced = {}
24887 };
24888 return model;
24889 }
24890
24891 const auto dummy_test_model_axis_float16_dim4_axis3_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis3_all_inputs_as_internal_2());
24892
24893 } // namespace generated_tests::softmax_v1_2
24894
24895 namespace generated_tests::softmax_v1_2 {
24896
get_test_model_axis_float16_dim4_axis3_neg_2()24897 const TestModel& get_test_model_axis_float16_dim4_axis3_neg_2() {
24898 static TestModel model = {
24899 .expectFailure = false,
24900 .expectedMultinomialDistributionTolerance = 0,
24901 .isRelaxed = false,
24902 .main = { // axis
24903 .inputIndexes = {0},
24904 .operands = {{ // op1
24905 .channelQuant = {},
24906 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
24907 .dimensions = {2, 2, 2, 5},
24908 .isIgnored = false,
24909 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
24910 .numberOfConsumers = 1,
24911 .scale = 0.0f,
24912 .type = TestOperandType::TENSOR_FLOAT16,
24913 .zeroPoint = 0
24914 }, { // param3
24915 .channelQuant = {},
24916 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24917 .dimensions = {},
24918 .isIgnored = false,
24919 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24920 .numberOfConsumers = 1,
24921 .scale = 0.0f,
24922 .type = TestOperandType::FLOAT16,
24923 .zeroPoint = 0
24924 }, { // axis
24925 .channelQuant = {},
24926 .data = TestBuffer::createFromVector<int32_t>({-1}),
24927 .dimensions = {},
24928 .isIgnored = false,
24929 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24930 .numberOfConsumers = 1,
24931 .scale = 0.0f,
24932 .type = TestOperandType::INT32,
24933 .zeroPoint = 0
24934 }, { // op2
24935 .channelQuant = {},
24936 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
24937 .dimensions = {2, 2, 2, 5},
24938 .isIgnored = false,
24939 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
24940 .numberOfConsumers = 0,
24941 .scale = 0.0f,
24942 .type = TestOperandType::TENSOR_FLOAT16,
24943 .zeroPoint = 0
24944 }},
24945 .operations = {{
24946 .inputs = {0, 1, 2},
24947 .outputs = {3},
24948 .type = TestOperationType::SOFTMAX
24949 }},
24950 .outputIndexes = {3}
24951 },
24952 .minSupportedVersion = TestHalVersion::V1_2,
24953 .referenced = {}
24954 };
24955 return model;
24956 }
24957
24958 const auto dummy_test_model_axis_float16_dim4_axis3_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3_neg_2", get_test_model_axis_float16_dim4_axis3_neg_2());
24959
24960 } // namespace generated_tests::softmax_v1_2
24961
24962 namespace generated_tests::softmax_v1_2 {
24963
get_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal_2()24964 const TestModel& get_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal_2() {
24965 static TestModel model = {
24966 .expectFailure = false,
24967 .expectedMultinomialDistributionTolerance = 0,
24968 .isRelaxed = false,
24969 .main = { // axis
24970 .inputIndexes = {4},
24971 .operands = {{ // op1
24972 .channelQuant = {},
24973 .data = TestBuffer::createFromVector<_Float16>({}),
24974 .dimensions = {2, 2, 2, 5},
24975 .isIgnored = false,
24976 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
24977 .numberOfConsumers = 1,
24978 .scale = 0.0f,
24979 .type = TestOperandType::TENSOR_FLOAT16,
24980 .zeroPoint = 0
24981 }, { // param3
24982 .channelQuant = {},
24983 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
24984 .dimensions = {},
24985 .isIgnored = false,
24986 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24987 .numberOfConsumers = 1,
24988 .scale = 0.0f,
24989 .type = TestOperandType::FLOAT16,
24990 .zeroPoint = 0
24991 }, { // axis
24992 .channelQuant = {},
24993 .data = TestBuffer::createFromVector<int32_t>({-1}),
24994 .dimensions = {},
24995 .isIgnored = false,
24996 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
24997 .numberOfConsumers = 1,
24998 .scale = 0.0f,
24999 .type = TestOperandType::INT32,
25000 .zeroPoint = 0
25001 }, { // op2
25002 .channelQuant = {},
25003 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25004 .dimensions = {2, 2, 2, 5},
25005 .isIgnored = false,
25006 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25007 .numberOfConsumers = 0,
25008 .scale = 0.0f,
25009 .type = TestOperandType::TENSOR_FLOAT16,
25010 .zeroPoint = 0
25011 }, { // op1_new
25012 .channelQuant = {},
25013 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
25014 .dimensions = {2, 2, 2, 5},
25015 .isIgnored = false,
25016 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25017 .numberOfConsumers = 1,
25018 .scale = 0.0f,
25019 .type = TestOperandType::TENSOR_FLOAT16,
25020 .zeroPoint = 0
25021 }, { // placeholder151
25022 .channelQuant = {},
25023 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
25024 .dimensions = {1},
25025 .isIgnored = false,
25026 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25027 .numberOfConsumers = 1,
25028 .scale = 0.0f,
25029 .type = TestOperandType::TENSOR_FLOAT16,
25030 .zeroPoint = 0
25031 }, { // param169
25032 .channelQuant = {},
25033 .data = TestBuffer::createFromVector<int32_t>({0}),
25034 .dimensions = {},
25035 .isIgnored = false,
25036 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25037 .numberOfConsumers = 1,
25038 .scale = 0.0f,
25039 .type = TestOperandType::INT32,
25040 .zeroPoint = 0
25041 }},
25042 .operations = {{
25043 .inputs = {4, 5, 6},
25044 .outputs = {0},
25045 .type = TestOperationType::ADD
25046 }, {
25047 .inputs = {0, 1, 2},
25048 .outputs = {3},
25049 .type = TestOperationType::SOFTMAX
25050 }},
25051 .outputIndexes = {3}
25052 },
25053 .minSupportedVersion = TestHalVersion::V1_2,
25054 .referenced = {}
25055 };
25056 return model;
25057 }
25058
25059 const auto dummy_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim4_axis3_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim4_axis3_neg_all_inputs_as_internal_2());
25060
25061 } // namespace generated_tests::softmax_v1_2
25062
25063 namespace generated_tests::softmax_v1_2 {
25064
get_test_model_axis_float16_dim3_axis0_2()25065 const TestModel& get_test_model_axis_float16_dim3_axis0_2() {
25066 static TestModel model = {
25067 .expectFailure = false,
25068 .expectedMultinomialDistributionTolerance = 0,
25069 .isRelaxed = false,
25070 .main = { // axis
25071 .inputIndexes = {0},
25072 .operands = {{ // op1
25073 .channelQuant = {},
25074 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
25075 .dimensions = {5, 2, 2},
25076 .isIgnored = false,
25077 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25078 .numberOfConsumers = 1,
25079 .scale = 0.0f,
25080 .type = TestOperandType::TENSOR_FLOAT16,
25081 .zeroPoint = 0
25082 }, { // param3
25083 .channelQuant = {},
25084 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25085 .dimensions = {},
25086 .isIgnored = false,
25087 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25088 .numberOfConsumers = 1,
25089 .scale = 0.0f,
25090 .type = TestOperandType::FLOAT16,
25091 .zeroPoint = 0
25092 }, { // axis
25093 .channelQuant = {},
25094 .data = TestBuffer::createFromVector<int32_t>({0}),
25095 .dimensions = {},
25096 .isIgnored = false,
25097 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25098 .numberOfConsumers = 1,
25099 .scale = 0.0f,
25100 .type = TestOperandType::INT32,
25101 .zeroPoint = 0
25102 }, { // op2
25103 .channelQuant = {},
25104 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25105 .dimensions = {5, 2, 2},
25106 .isIgnored = false,
25107 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25108 .numberOfConsumers = 0,
25109 .scale = 0.0f,
25110 .type = TestOperandType::TENSOR_FLOAT16,
25111 .zeroPoint = 0
25112 }},
25113 .operations = {{
25114 .inputs = {0, 1, 2},
25115 .outputs = {3},
25116 .type = TestOperationType::SOFTMAX
25117 }},
25118 .outputIndexes = {3}
25119 },
25120 .minSupportedVersion = TestHalVersion::V1_2,
25121 .referenced = {}
25122 };
25123 return model;
25124 }
25125
25126 const auto dummy_test_model_axis_float16_dim3_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0_2", get_test_model_axis_float16_dim3_axis0_2());
25127
25128 } // namespace generated_tests::softmax_v1_2
25129
25130 namespace generated_tests::softmax_v1_2 {
25131
get_test_model_axis_float16_dim3_axis0_all_inputs_as_internal_2()25132 const TestModel& get_test_model_axis_float16_dim3_axis0_all_inputs_as_internal_2() {
25133 static TestModel model = {
25134 .expectFailure = false,
25135 .expectedMultinomialDistributionTolerance = 0,
25136 .isRelaxed = false,
25137 .main = { // axis
25138 .inputIndexes = {4},
25139 .operands = {{ // op1
25140 .channelQuant = {},
25141 .data = TestBuffer::createFromVector<_Float16>({}),
25142 .dimensions = {5, 2, 2},
25143 .isIgnored = false,
25144 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
25145 .numberOfConsumers = 1,
25146 .scale = 0.0f,
25147 .type = TestOperandType::TENSOR_FLOAT16,
25148 .zeroPoint = 0
25149 }, { // param3
25150 .channelQuant = {},
25151 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25152 .dimensions = {},
25153 .isIgnored = false,
25154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25155 .numberOfConsumers = 1,
25156 .scale = 0.0f,
25157 .type = TestOperandType::FLOAT16,
25158 .zeroPoint = 0
25159 }, { // axis
25160 .channelQuant = {},
25161 .data = TestBuffer::createFromVector<int32_t>({0}),
25162 .dimensions = {},
25163 .isIgnored = false,
25164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25165 .numberOfConsumers = 1,
25166 .scale = 0.0f,
25167 .type = TestOperandType::INT32,
25168 .zeroPoint = 0
25169 }, { // op2
25170 .channelQuant = {},
25171 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25172 .dimensions = {5, 2, 2},
25173 .isIgnored = false,
25174 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25175 .numberOfConsumers = 0,
25176 .scale = 0.0f,
25177 .type = TestOperandType::TENSOR_FLOAT16,
25178 .zeroPoint = 0
25179 }, { // op1_new
25180 .channelQuant = {},
25181 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
25182 .dimensions = {5, 2, 2},
25183 .isIgnored = false,
25184 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25185 .numberOfConsumers = 1,
25186 .scale = 0.0f,
25187 .type = TestOperandType::TENSOR_FLOAT16,
25188 .zeroPoint = 0
25189 }, { // placeholder152
25190 .channelQuant = {},
25191 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
25192 .dimensions = {1},
25193 .isIgnored = false,
25194 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25195 .numberOfConsumers = 1,
25196 .scale = 0.0f,
25197 .type = TestOperandType::TENSOR_FLOAT16,
25198 .zeroPoint = 0
25199 }, { // param170
25200 .channelQuant = {},
25201 .data = TestBuffer::createFromVector<int32_t>({0}),
25202 .dimensions = {},
25203 .isIgnored = false,
25204 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25205 .numberOfConsumers = 1,
25206 .scale = 0.0f,
25207 .type = TestOperandType::INT32,
25208 .zeroPoint = 0
25209 }},
25210 .operations = {{
25211 .inputs = {4, 5, 6},
25212 .outputs = {0},
25213 .type = TestOperationType::ADD
25214 }, {
25215 .inputs = {0, 1, 2},
25216 .outputs = {3},
25217 .type = TestOperationType::SOFTMAX
25218 }},
25219 .outputIndexes = {3}
25220 },
25221 .minSupportedVersion = TestHalVersion::V1_2,
25222 .referenced = {}
25223 };
25224 return model;
25225 }
25226
25227 const auto dummy_test_model_axis_float16_dim3_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0_all_inputs_as_internal_2", get_test_model_axis_float16_dim3_axis0_all_inputs_as_internal_2());
25228
25229 } // namespace generated_tests::softmax_v1_2
25230
25231 namespace generated_tests::softmax_v1_2 {
25232
get_test_model_axis_float16_dim3_axis0_neg_2()25233 const TestModel& get_test_model_axis_float16_dim3_axis0_neg_2() {
25234 static TestModel model = {
25235 .expectFailure = false,
25236 .expectedMultinomialDistributionTolerance = 0,
25237 .isRelaxed = false,
25238 .main = { // axis
25239 .inputIndexes = {0},
25240 .operands = {{ // op1
25241 .channelQuant = {},
25242 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
25243 .dimensions = {5, 2, 2},
25244 .isIgnored = false,
25245 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25246 .numberOfConsumers = 1,
25247 .scale = 0.0f,
25248 .type = TestOperandType::TENSOR_FLOAT16,
25249 .zeroPoint = 0
25250 }, { // param3
25251 .channelQuant = {},
25252 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25253 .dimensions = {},
25254 .isIgnored = false,
25255 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25256 .numberOfConsumers = 1,
25257 .scale = 0.0f,
25258 .type = TestOperandType::FLOAT16,
25259 .zeroPoint = 0
25260 }, { // axis
25261 .channelQuant = {},
25262 .data = TestBuffer::createFromVector<int32_t>({-3}),
25263 .dimensions = {},
25264 .isIgnored = false,
25265 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25266 .numberOfConsumers = 1,
25267 .scale = 0.0f,
25268 .type = TestOperandType::INT32,
25269 .zeroPoint = 0
25270 }, { // op2
25271 .channelQuant = {},
25272 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25273 .dimensions = {5, 2, 2},
25274 .isIgnored = false,
25275 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25276 .numberOfConsumers = 0,
25277 .scale = 0.0f,
25278 .type = TestOperandType::TENSOR_FLOAT16,
25279 .zeroPoint = 0
25280 }},
25281 .operations = {{
25282 .inputs = {0, 1, 2},
25283 .outputs = {3},
25284 .type = TestOperationType::SOFTMAX
25285 }},
25286 .outputIndexes = {3}
25287 },
25288 .minSupportedVersion = TestHalVersion::V1_2,
25289 .referenced = {}
25290 };
25291 return model;
25292 }
25293
25294 const auto dummy_test_model_axis_float16_dim3_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0_neg_2", get_test_model_axis_float16_dim3_axis0_neg_2());
25295
25296 } // namespace generated_tests::softmax_v1_2
25297
25298 namespace generated_tests::softmax_v1_2 {
25299
get_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal_2()25300 const TestModel& get_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal_2() {
25301 static TestModel model = {
25302 .expectFailure = false,
25303 .expectedMultinomialDistributionTolerance = 0,
25304 .isRelaxed = false,
25305 .main = { // axis
25306 .inputIndexes = {4},
25307 .operands = {{ // op1
25308 .channelQuant = {},
25309 .data = TestBuffer::createFromVector<_Float16>({}),
25310 .dimensions = {5, 2, 2},
25311 .isIgnored = false,
25312 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
25313 .numberOfConsumers = 1,
25314 .scale = 0.0f,
25315 .type = TestOperandType::TENSOR_FLOAT16,
25316 .zeroPoint = 0
25317 }, { // param3
25318 .channelQuant = {},
25319 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25320 .dimensions = {},
25321 .isIgnored = false,
25322 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25323 .numberOfConsumers = 1,
25324 .scale = 0.0f,
25325 .type = TestOperandType::FLOAT16,
25326 .zeroPoint = 0
25327 }, { // axis
25328 .channelQuant = {},
25329 .data = TestBuffer::createFromVector<int32_t>({-3}),
25330 .dimensions = {},
25331 .isIgnored = false,
25332 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25333 .numberOfConsumers = 1,
25334 .scale = 0.0f,
25335 .type = TestOperandType::INT32,
25336 .zeroPoint = 0
25337 }, { // op2
25338 .channelQuant = {},
25339 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25340 .dimensions = {5, 2, 2},
25341 .isIgnored = false,
25342 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25343 .numberOfConsumers = 0,
25344 .scale = 0.0f,
25345 .type = TestOperandType::TENSOR_FLOAT16,
25346 .zeroPoint = 0
25347 }, { // op1_new
25348 .channelQuant = {},
25349 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 1.0f, -1.0f, 2.0f, -2.0f, 2.0f, -2.0f, 3.0f, -3.0f, 3.0f, -3.0f, 4.0f, -4.0f, 4.0f, -4.0f, 5.0f, -5.0f, 5.0f, -5.0f}),
25350 .dimensions = {5, 2, 2},
25351 .isIgnored = false,
25352 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25353 .numberOfConsumers = 1,
25354 .scale = 0.0f,
25355 .type = TestOperandType::TENSOR_FLOAT16,
25356 .zeroPoint = 0
25357 }, { // placeholder153
25358 .channelQuant = {},
25359 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
25360 .dimensions = {1},
25361 .isIgnored = false,
25362 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25363 .numberOfConsumers = 1,
25364 .scale = 0.0f,
25365 .type = TestOperandType::TENSOR_FLOAT16,
25366 .zeroPoint = 0
25367 }, { // param171
25368 .channelQuant = {},
25369 .data = TestBuffer::createFromVector<int32_t>({0}),
25370 .dimensions = {},
25371 .isIgnored = false,
25372 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25373 .numberOfConsumers = 1,
25374 .scale = 0.0f,
25375 .type = TestOperandType::INT32,
25376 .zeroPoint = 0
25377 }},
25378 .operations = {{
25379 .inputs = {4, 5, 6},
25380 .outputs = {0},
25381 .type = TestOperationType::ADD
25382 }, {
25383 .inputs = {0, 1, 2},
25384 .outputs = {3},
25385 .type = TestOperationType::SOFTMAX
25386 }},
25387 .outputIndexes = {3}
25388 },
25389 .minSupportedVersion = TestHalVersion::V1_2,
25390 .referenced = {}
25391 };
25392 return model;
25393 }
25394
25395 const auto dummy_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim3_axis0_neg_all_inputs_as_internal_2());
25396
25397 } // namespace generated_tests::softmax_v1_2
25398
25399 namespace generated_tests::softmax_v1_2 {
25400
get_test_model_axis_float16_dim3_axis1_2()25401 const TestModel& get_test_model_axis_float16_dim3_axis1_2() {
25402 static TestModel model = {
25403 .expectFailure = false,
25404 .expectedMultinomialDistributionTolerance = 0,
25405 .isRelaxed = false,
25406 .main = { // axis
25407 .inputIndexes = {0},
25408 .operands = {{ // op1
25409 .channelQuant = {},
25410 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
25411 .dimensions = {2, 5, 2},
25412 .isIgnored = false,
25413 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25414 .numberOfConsumers = 1,
25415 .scale = 0.0f,
25416 .type = TestOperandType::TENSOR_FLOAT16,
25417 .zeroPoint = 0
25418 }, { // param3
25419 .channelQuant = {},
25420 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25421 .dimensions = {},
25422 .isIgnored = false,
25423 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25424 .numberOfConsumers = 1,
25425 .scale = 0.0f,
25426 .type = TestOperandType::FLOAT16,
25427 .zeroPoint = 0
25428 }, { // axis
25429 .channelQuant = {},
25430 .data = TestBuffer::createFromVector<int32_t>({1}),
25431 .dimensions = {},
25432 .isIgnored = false,
25433 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25434 .numberOfConsumers = 1,
25435 .scale = 0.0f,
25436 .type = TestOperandType::INT32,
25437 .zeroPoint = 0
25438 }, { // op2
25439 .channelQuant = {},
25440 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25441 .dimensions = {2, 5, 2},
25442 .isIgnored = false,
25443 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25444 .numberOfConsumers = 0,
25445 .scale = 0.0f,
25446 .type = TestOperandType::TENSOR_FLOAT16,
25447 .zeroPoint = 0
25448 }},
25449 .operations = {{
25450 .inputs = {0, 1, 2},
25451 .outputs = {3},
25452 .type = TestOperationType::SOFTMAX
25453 }},
25454 .outputIndexes = {3}
25455 },
25456 .minSupportedVersion = TestHalVersion::V1_2,
25457 .referenced = {}
25458 };
25459 return model;
25460 }
25461
25462 const auto dummy_test_model_axis_float16_dim3_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1_2", get_test_model_axis_float16_dim3_axis1_2());
25463
25464 } // namespace generated_tests::softmax_v1_2
25465
25466 namespace generated_tests::softmax_v1_2 {
25467
get_test_model_axis_float16_dim3_axis1_all_inputs_as_internal_2()25468 const TestModel& get_test_model_axis_float16_dim3_axis1_all_inputs_as_internal_2() {
25469 static TestModel model = {
25470 .expectFailure = false,
25471 .expectedMultinomialDistributionTolerance = 0,
25472 .isRelaxed = false,
25473 .main = { // axis
25474 .inputIndexes = {4},
25475 .operands = {{ // op1
25476 .channelQuant = {},
25477 .data = TestBuffer::createFromVector<_Float16>({}),
25478 .dimensions = {2, 5, 2},
25479 .isIgnored = false,
25480 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
25481 .numberOfConsumers = 1,
25482 .scale = 0.0f,
25483 .type = TestOperandType::TENSOR_FLOAT16,
25484 .zeroPoint = 0
25485 }, { // param3
25486 .channelQuant = {},
25487 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25488 .dimensions = {},
25489 .isIgnored = false,
25490 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25491 .numberOfConsumers = 1,
25492 .scale = 0.0f,
25493 .type = TestOperandType::FLOAT16,
25494 .zeroPoint = 0
25495 }, { // axis
25496 .channelQuant = {},
25497 .data = TestBuffer::createFromVector<int32_t>({1}),
25498 .dimensions = {},
25499 .isIgnored = false,
25500 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25501 .numberOfConsumers = 1,
25502 .scale = 0.0f,
25503 .type = TestOperandType::INT32,
25504 .zeroPoint = 0
25505 }, { // op2
25506 .channelQuant = {},
25507 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25508 .dimensions = {2, 5, 2},
25509 .isIgnored = false,
25510 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25511 .numberOfConsumers = 0,
25512 .scale = 0.0f,
25513 .type = TestOperandType::TENSOR_FLOAT16,
25514 .zeroPoint = 0
25515 }, { // op1_new
25516 .channelQuant = {},
25517 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
25518 .dimensions = {2, 5, 2},
25519 .isIgnored = false,
25520 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25521 .numberOfConsumers = 1,
25522 .scale = 0.0f,
25523 .type = TestOperandType::TENSOR_FLOAT16,
25524 .zeroPoint = 0
25525 }, { // placeholder154
25526 .channelQuant = {},
25527 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
25528 .dimensions = {1},
25529 .isIgnored = false,
25530 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25531 .numberOfConsumers = 1,
25532 .scale = 0.0f,
25533 .type = TestOperandType::TENSOR_FLOAT16,
25534 .zeroPoint = 0
25535 }, { // param172
25536 .channelQuant = {},
25537 .data = TestBuffer::createFromVector<int32_t>({0}),
25538 .dimensions = {},
25539 .isIgnored = false,
25540 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25541 .numberOfConsumers = 1,
25542 .scale = 0.0f,
25543 .type = TestOperandType::INT32,
25544 .zeroPoint = 0
25545 }},
25546 .operations = {{
25547 .inputs = {4, 5, 6},
25548 .outputs = {0},
25549 .type = TestOperationType::ADD
25550 }, {
25551 .inputs = {0, 1, 2},
25552 .outputs = {3},
25553 .type = TestOperationType::SOFTMAX
25554 }},
25555 .outputIndexes = {3}
25556 },
25557 .minSupportedVersion = TestHalVersion::V1_2,
25558 .referenced = {}
25559 };
25560 return model;
25561 }
25562
25563 const auto dummy_test_model_axis_float16_dim3_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1_all_inputs_as_internal_2", get_test_model_axis_float16_dim3_axis1_all_inputs_as_internal_2());
25564
25565 } // namespace generated_tests::softmax_v1_2
25566
25567 namespace generated_tests::softmax_v1_2 {
25568
get_test_model_axis_float16_dim3_axis1_neg_2()25569 const TestModel& get_test_model_axis_float16_dim3_axis1_neg_2() {
25570 static TestModel model = {
25571 .expectFailure = false,
25572 .expectedMultinomialDistributionTolerance = 0,
25573 .isRelaxed = false,
25574 .main = { // axis
25575 .inputIndexes = {0},
25576 .operands = {{ // op1
25577 .channelQuant = {},
25578 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
25579 .dimensions = {2, 5, 2},
25580 .isIgnored = false,
25581 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25582 .numberOfConsumers = 1,
25583 .scale = 0.0f,
25584 .type = TestOperandType::TENSOR_FLOAT16,
25585 .zeroPoint = 0
25586 }, { // param3
25587 .channelQuant = {},
25588 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25589 .dimensions = {},
25590 .isIgnored = false,
25591 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25592 .numberOfConsumers = 1,
25593 .scale = 0.0f,
25594 .type = TestOperandType::FLOAT16,
25595 .zeroPoint = 0
25596 }, { // axis
25597 .channelQuant = {},
25598 .data = TestBuffer::createFromVector<int32_t>({-2}),
25599 .dimensions = {},
25600 .isIgnored = false,
25601 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25602 .numberOfConsumers = 1,
25603 .scale = 0.0f,
25604 .type = TestOperandType::INT32,
25605 .zeroPoint = 0
25606 }, { // op2
25607 .channelQuant = {},
25608 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25609 .dimensions = {2, 5, 2},
25610 .isIgnored = false,
25611 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25612 .numberOfConsumers = 0,
25613 .scale = 0.0f,
25614 .type = TestOperandType::TENSOR_FLOAT16,
25615 .zeroPoint = 0
25616 }},
25617 .operations = {{
25618 .inputs = {0, 1, 2},
25619 .outputs = {3},
25620 .type = TestOperationType::SOFTMAX
25621 }},
25622 .outputIndexes = {3}
25623 },
25624 .minSupportedVersion = TestHalVersion::V1_2,
25625 .referenced = {}
25626 };
25627 return model;
25628 }
25629
25630 const auto dummy_test_model_axis_float16_dim3_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1_neg_2", get_test_model_axis_float16_dim3_axis1_neg_2());
25631
25632 } // namespace generated_tests::softmax_v1_2
25633
25634 namespace generated_tests::softmax_v1_2 {
25635
get_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal_2()25636 const TestModel& get_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal_2() {
25637 static TestModel model = {
25638 .expectFailure = false,
25639 .expectedMultinomialDistributionTolerance = 0,
25640 .isRelaxed = false,
25641 .main = { // axis
25642 .inputIndexes = {4},
25643 .operands = {{ // op1
25644 .channelQuant = {},
25645 .data = TestBuffer::createFromVector<_Float16>({}),
25646 .dimensions = {2, 5, 2},
25647 .isIgnored = false,
25648 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
25649 .numberOfConsumers = 1,
25650 .scale = 0.0f,
25651 .type = TestOperandType::TENSOR_FLOAT16,
25652 .zeroPoint = 0
25653 }, { // param3
25654 .channelQuant = {},
25655 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25656 .dimensions = {},
25657 .isIgnored = false,
25658 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25659 .numberOfConsumers = 1,
25660 .scale = 0.0f,
25661 .type = TestOperandType::FLOAT16,
25662 .zeroPoint = 0
25663 }, { // axis
25664 .channelQuant = {},
25665 .data = TestBuffer::createFromVector<int32_t>({-2}),
25666 .dimensions = {},
25667 .isIgnored = false,
25668 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25669 .numberOfConsumers = 1,
25670 .scale = 0.0f,
25671 .type = TestOperandType::INT32,
25672 .zeroPoint = 0
25673 }, { // op2
25674 .channelQuant = {},
25675 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25676 .dimensions = {2, 5, 2},
25677 .isIgnored = false,
25678 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25679 .numberOfConsumers = 0,
25680 .scale = 0.0f,
25681 .type = TestOperandType::TENSOR_FLOAT16,
25682 .zeroPoint = 0
25683 }, { // op1_new
25684 .channelQuant = {},
25685 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f, 1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
25686 .dimensions = {2, 5, 2},
25687 .isIgnored = false,
25688 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25689 .numberOfConsumers = 1,
25690 .scale = 0.0f,
25691 .type = TestOperandType::TENSOR_FLOAT16,
25692 .zeroPoint = 0
25693 }, { // placeholder155
25694 .channelQuant = {},
25695 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
25696 .dimensions = {1},
25697 .isIgnored = false,
25698 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25699 .numberOfConsumers = 1,
25700 .scale = 0.0f,
25701 .type = TestOperandType::TENSOR_FLOAT16,
25702 .zeroPoint = 0
25703 }, { // param173
25704 .channelQuant = {},
25705 .data = TestBuffer::createFromVector<int32_t>({0}),
25706 .dimensions = {},
25707 .isIgnored = false,
25708 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25709 .numberOfConsumers = 1,
25710 .scale = 0.0f,
25711 .type = TestOperandType::INT32,
25712 .zeroPoint = 0
25713 }},
25714 .operations = {{
25715 .inputs = {4, 5, 6},
25716 .outputs = {0},
25717 .type = TestOperationType::ADD
25718 }, {
25719 .inputs = {0, 1, 2},
25720 .outputs = {3},
25721 .type = TestOperationType::SOFTMAX
25722 }},
25723 .outputIndexes = {3}
25724 },
25725 .minSupportedVersion = TestHalVersion::V1_2,
25726 .referenced = {}
25727 };
25728 return model;
25729 }
25730
25731 const auto dummy_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim3_axis1_neg_all_inputs_as_internal_2());
25732
25733 } // namespace generated_tests::softmax_v1_2
25734
25735 namespace generated_tests::softmax_v1_2 {
25736
get_test_model_axis_float16_dim3_axis2_2()25737 const TestModel& get_test_model_axis_float16_dim3_axis2_2() {
25738 static TestModel model = {
25739 .expectFailure = false,
25740 .expectedMultinomialDistributionTolerance = 0,
25741 .isRelaxed = false,
25742 .main = { // axis
25743 .inputIndexes = {0},
25744 .operands = {{ // op1
25745 .channelQuant = {},
25746 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
25747 .dimensions = {2, 2, 5},
25748 .isIgnored = false,
25749 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25750 .numberOfConsumers = 1,
25751 .scale = 0.0f,
25752 .type = TestOperandType::TENSOR_FLOAT16,
25753 .zeroPoint = 0
25754 }, { // param3
25755 .channelQuant = {},
25756 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25757 .dimensions = {},
25758 .isIgnored = false,
25759 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25760 .numberOfConsumers = 1,
25761 .scale = 0.0f,
25762 .type = TestOperandType::FLOAT16,
25763 .zeroPoint = 0
25764 }, { // axis
25765 .channelQuant = {},
25766 .data = TestBuffer::createFromVector<int32_t>({2}),
25767 .dimensions = {},
25768 .isIgnored = false,
25769 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25770 .numberOfConsumers = 1,
25771 .scale = 0.0f,
25772 .type = TestOperandType::INT32,
25773 .zeroPoint = 0
25774 }, { // op2
25775 .channelQuant = {},
25776 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25777 .dimensions = {2, 2, 5},
25778 .isIgnored = false,
25779 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25780 .numberOfConsumers = 0,
25781 .scale = 0.0f,
25782 .type = TestOperandType::TENSOR_FLOAT16,
25783 .zeroPoint = 0
25784 }},
25785 .operations = {{
25786 .inputs = {0, 1, 2},
25787 .outputs = {3},
25788 .type = TestOperationType::SOFTMAX
25789 }},
25790 .outputIndexes = {3}
25791 },
25792 .minSupportedVersion = TestHalVersion::V1_2,
25793 .referenced = {}
25794 };
25795 return model;
25796 }
25797
25798 const auto dummy_test_model_axis_float16_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2_2", get_test_model_axis_float16_dim3_axis2_2());
25799
25800 } // namespace generated_tests::softmax_v1_2
25801
25802 namespace generated_tests::softmax_v1_2 {
25803
get_test_model_axis_float16_dim3_axis2_all_inputs_as_internal_2()25804 const TestModel& get_test_model_axis_float16_dim3_axis2_all_inputs_as_internal_2() {
25805 static TestModel model = {
25806 .expectFailure = false,
25807 .expectedMultinomialDistributionTolerance = 0,
25808 .isRelaxed = false,
25809 .main = { // axis
25810 .inputIndexes = {4},
25811 .operands = {{ // op1
25812 .channelQuant = {},
25813 .data = TestBuffer::createFromVector<_Float16>({}),
25814 .dimensions = {2, 2, 5},
25815 .isIgnored = false,
25816 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
25817 .numberOfConsumers = 1,
25818 .scale = 0.0f,
25819 .type = TestOperandType::TENSOR_FLOAT16,
25820 .zeroPoint = 0
25821 }, { // param3
25822 .channelQuant = {},
25823 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25824 .dimensions = {},
25825 .isIgnored = false,
25826 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25827 .numberOfConsumers = 1,
25828 .scale = 0.0f,
25829 .type = TestOperandType::FLOAT16,
25830 .zeroPoint = 0
25831 }, { // axis
25832 .channelQuant = {},
25833 .data = TestBuffer::createFromVector<int32_t>({2}),
25834 .dimensions = {},
25835 .isIgnored = false,
25836 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25837 .numberOfConsumers = 1,
25838 .scale = 0.0f,
25839 .type = TestOperandType::INT32,
25840 .zeroPoint = 0
25841 }, { // op2
25842 .channelQuant = {},
25843 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25844 .dimensions = {2, 2, 5},
25845 .isIgnored = false,
25846 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25847 .numberOfConsumers = 0,
25848 .scale = 0.0f,
25849 .type = TestOperandType::TENSOR_FLOAT16,
25850 .zeroPoint = 0
25851 }, { // op1_new
25852 .channelQuant = {},
25853 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
25854 .dimensions = {2, 2, 5},
25855 .isIgnored = false,
25856 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25857 .numberOfConsumers = 1,
25858 .scale = 0.0f,
25859 .type = TestOperandType::TENSOR_FLOAT16,
25860 .zeroPoint = 0
25861 }, { // placeholder156
25862 .channelQuant = {},
25863 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
25864 .dimensions = {1},
25865 .isIgnored = false,
25866 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25867 .numberOfConsumers = 1,
25868 .scale = 0.0f,
25869 .type = TestOperandType::TENSOR_FLOAT16,
25870 .zeroPoint = 0
25871 }, { // param174
25872 .channelQuant = {},
25873 .data = TestBuffer::createFromVector<int32_t>({0}),
25874 .dimensions = {},
25875 .isIgnored = false,
25876 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25877 .numberOfConsumers = 1,
25878 .scale = 0.0f,
25879 .type = TestOperandType::INT32,
25880 .zeroPoint = 0
25881 }},
25882 .operations = {{
25883 .inputs = {4, 5, 6},
25884 .outputs = {0},
25885 .type = TestOperationType::ADD
25886 }, {
25887 .inputs = {0, 1, 2},
25888 .outputs = {3},
25889 .type = TestOperationType::SOFTMAX
25890 }},
25891 .outputIndexes = {3}
25892 },
25893 .minSupportedVersion = TestHalVersion::V1_2,
25894 .referenced = {}
25895 };
25896 return model;
25897 }
25898
25899 const auto dummy_test_model_axis_float16_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2_all_inputs_as_internal_2", get_test_model_axis_float16_dim3_axis2_all_inputs_as_internal_2());
25900
25901 } // namespace generated_tests::softmax_v1_2
25902
25903 namespace generated_tests::softmax_v1_2 {
25904
get_test_model_axis_float16_dim3_axis2_neg_2()25905 const TestModel& get_test_model_axis_float16_dim3_axis2_neg_2() {
25906 static TestModel model = {
25907 .expectFailure = false,
25908 .expectedMultinomialDistributionTolerance = 0,
25909 .isRelaxed = false,
25910 .main = { // axis
25911 .inputIndexes = {0},
25912 .operands = {{ // op1
25913 .channelQuant = {},
25914 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
25915 .dimensions = {2, 2, 5},
25916 .isIgnored = false,
25917 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
25918 .numberOfConsumers = 1,
25919 .scale = 0.0f,
25920 .type = TestOperandType::TENSOR_FLOAT16,
25921 .zeroPoint = 0
25922 }, { // param3
25923 .channelQuant = {},
25924 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25925 .dimensions = {},
25926 .isIgnored = false,
25927 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25928 .numberOfConsumers = 1,
25929 .scale = 0.0f,
25930 .type = TestOperandType::FLOAT16,
25931 .zeroPoint = 0
25932 }, { // axis
25933 .channelQuant = {},
25934 .data = TestBuffer::createFromVector<int32_t>({-1}),
25935 .dimensions = {},
25936 .isIgnored = false,
25937 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25938 .numberOfConsumers = 1,
25939 .scale = 0.0f,
25940 .type = TestOperandType::INT32,
25941 .zeroPoint = 0
25942 }, { // op2
25943 .channelQuant = {},
25944 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
25945 .dimensions = {2, 2, 5},
25946 .isIgnored = false,
25947 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
25948 .numberOfConsumers = 0,
25949 .scale = 0.0f,
25950 .type = TestOperandType::TENSOR_FLOAT16,
25951 .zeroPoint = 0
25952 }},
25953 .operations = {{
25954 .inputs = {0, 1, 2},
25955 .outputs = {3},
25956 .type = TestOperationType::SOFTMAX
25957 }},
25958 .outputIndexes = {3}
25959 },
25960 .minSupportedVersion = TestHalVersion::V1_2,
25961 .referenced = {}
25962 };
25963 return model;
25964 }
25965
25966 const auto dummy_test_model_axis_float16_dim3_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2_neg_2", get_test_model_axis_float16_dim3_axis2_neg_2());
25967
25968 } // namespace generated_tests::softmax_v1_2
25969
25970 namespace generated_tests::softmax_v1_2 {
25971
get_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal_2()25972 const TestModel& get_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal_2() {
25973 static TestModel model = {
25974 .expectFailure = false,
25975 .expectedMultinomialDistributionTolerance = 0,
25976 .isRelaxed = false,
25977 .main = { // axis
25978 .inputIndexes = {4},
25979 .operands = {{ // op1
25980 .channelQuant = {},
25981 .data = TestBuffer::createFromVector<_Float16>({}),
25982 .dimensions = {2, 2, 5},
25983 .isIgnored = false,
25984 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
25985 .numberOfConsumers = 1,
25986 .scale = 0.0f,
25987 .type = TestOperandType::TENSOR_FLOAT16,
25988 .zeroPoint = 0
25989 }, { // param3
25990 .channelQuant = {},
25991 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
25992 .dimensions = {},
25993 .isIgnored = false,
25994 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
25995 .numberOfConsumers = 1,
25996 .scale = 0.0f,
25997 .type = TestOperandType::FLOAT16,
25998 .zeroPoint = 0
25999 }, { // axis
26000 .channelQuant = {},
26001 .data = TestBuffer::createFromVector<int32_t>({-1}),
26002 .dimensions = {},
26003 .isIgnored = false,
26004 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26005 .numberOfConsumers = 1,
26006 .scale = 0.0f,
26007 .type = TestOperandType::INT32,
26008 .zeroPoint = 0
26009 }, { // op2
26010 .channelQuant = {},
26011 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26012 .dimensions = {2, 2, 5},
26013 .isIgnored = false,
26014 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26015 .numberOfConsumers = 0,
26016 .scale = 0.0f,
26017 .type = TestOperandType::TENSOR_FLOAT16,
26018 .zeroPoint = 0
26019 }, { // op1_new
26020 .channelQuant = {},
26021 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
26022 .dimensions = {2, 2, 5},
26023 .isIgnored = false,
26024 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26025 .numberOfConsumers = 1,
26026 .scale = 0.0f,
26027 .type = TestOperandType::TENSOR_FLOAT16,
26028 .zeroPoint = 0
26029 }, { // placeholder157
26030 .channelQuant = {},
26031 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
26032 .dimensions = {1},
26033 .isIgnored = false,
26034 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26035 .numberOfConsumers = 1,
26036 .scale = 0.0f,
26037 .type = TestOperandType::TENSOR_FLOAT16,
26038 .zeroPoint = 0
26039 }, { // param175
26040 .channelQuant = {},
26041 .data = TestBuffer::createFromVector<int32_t>({0}),
26042 .dimensions = {},
26043 .isIgnored = false,
26044 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26045 .numberOfConsumers = 1,
26046 .scale = 0.0f,
26047 .type = TestOperandType::INT32,
26048 .zeroPoint = 0
26049 }},
26050 .operations = {{
26051 .inputs = {4, 5, 6},
26052 .outputs = {0},
26053 .type = TestOperationType::ADD
26054 }, {
26055 .inputs = {0, 1, 2},
26056 .outputs = {3},
26057 .type = TestOperationType::SOFTMAX
26058 }},
26059 .outputIndexes = {3}
26060 },
26061 .minSupportedVersion = TestHalVersion::V1_2,
26062 .referenced = {}
26063 };
26064 return model;
26065 }
26066
26067 const auto dummy_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim3_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim3_axis2_neg_all_inputs_as_internal_2());
26068
26069 } // namespace generated_tests::softmax_v1_2
26070
26071 namespace generated_tests::softmax_v1_2 {
26072
get_test_model_axis_float16_dim2_axis0_2()26073 const TestModel& get_test_model_axis_float16_dim2_axis0_2() {
26074 static TestModel model = {
26075 .expectFailure = false,
26076 .expectedMultinomialDistributionTolerance = 0,
26077 .isRelaxed = false,
26078 .main = { // axis
26079 .inputIndexes = {0},
26080 .operands = {{ // op1
26081 .channelQuant = {},
26082 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
26083 .dimensions = {5, 2},
26084 .isIgnored = false,
26085 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26086 .numberOfConsumers = 1,
26087 .scale = 0.0f,
26088 .type = TestOperandType::TENSOR_FLOAT16,
26089 .zeroPoint = 0
26090 }, { // param3
26091 .channelQuant = {},
26092 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26093 .dimensions = {},
26094 .isIgnored = false,
26095 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26096 .numberOfConsumers = 1,
26097 .scale = 0.0f,
26098 .type = TestOperandType::FLOAT16,
26099 .zeroPoint = 0
26100 }, { // axis
26101 .channelQuant = {},
26102 .data = TestBuffer::createFromVector<int32_t>({0}),
26103 .dimensions = {},
26104 .isIgnored = false,
26105 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26106 .numberOfConsumers = 1,
26107 .scale = 0.0f,
26108 .type = TestOperandType::INT32,
26109 .zeroPoint = 0
26110 }, { // op2
26111 .channelQuant = {},
26112 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26113 .dimensions = {5, 2},
26114 .isIgnored = false,
26115 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26116 .numberOfConsumers = 0,
26117 .scale = 0.0f,
26118 .type = TestOperandType::TENSOR_FLOAT16,
26119 .zeroPoint = 0
26120 }},
26121 .operations = {{
26122 .inputs = {0, 1, 2},
26123 .outputs = {3},
26124 .type = TestOperationType::SOFTMAX
26125 }},
26126 .outputIndexes = {3}
26127 },
26128 .minSupportedVersion = TestHalVersion::V1_2,
26129 .referenced = {}
26130 };
26131 return model;
26132 }
26133
26134 const auto dummy_test_model_axis_float16_dim2_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0_2", get_test_model_axis_float16_dim2_axis0_2());
26135
26136 } // namespace generated_tests::softmax_v1_2
26137
26138 namespace generated_tests::softmax_v1_2 {
26139
get_test_model_axis_float16_dim2_axis0_all_inputs_as_internal_2()26140 const TestModel& get_test_model_axis_float16_dim2_axis0_all_inputs_as_internal_2() {
26141 static TestModel model = {
26142 .expectFailure = false,
26143 .expectedMultinomialDistributionTolerance = 0,
26144 .isRelaxed = false,
26145 .main = { // axis
26146 .inputIndexes = {4},
26147 .operands = {{ // op1
26148 .channelQuant = {},
26149 .data = TestBuffer::createFromVector<_Float16>({}),
26150 .dimensions = {5, 2},
26151 .isIgnored = false,
26152 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
26153 .numberOfConsumers = 1,
26154 .scale = 0.0f,
26155 .type = TestOperandType::TENSOR_FLOAT16,
26156 .zeroPoint = 0
26157 }, { // param3
26158 .channelQuant = {},
26159 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26160 .dimensions = {},
26161 .isIgnored = false,
26162 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26163 .numberOfConsumers = 1,
26164 .scale = 0.0f,
26165 .type = TestOperandType::FLOAT16,
26166 .zeroPoint = 0
26167 }, { // axis
26168 .channelQuant = {},
26169 .data = TestBuffer::createFromVector<int32_t>({0}),
26170 .dimensions = {},
26171 .isIgnored = false,
26172 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26173 .numberOfConsumers = 1,
26174 .scale = 0.0f,
26175 .type = TestOperandType::INT32,
26176 .zeroPoint = 0
26177 }, { // op2
26178 .channelQuant = {},
26179 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26180 .dimensions = {5, 2},
26181 .isIgnored = false,
26182 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26183 .numberOfConsumers = 0,
26184 .scale = 0.0f,
26185 .type = TestOperandType::TENSOR_FLOAT16,
26186 .zeroPoint = 0
26187 }, { // op1_new
26188 .channelQuant = {},
26189 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
26190 .dimensions = {5, 2},
26191 .isIgnored = false,
26192 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26193 .numberOfConsumers = 1,
26194 .scale = 0.0f,
26195 .type = TestOperandType::TENSOR_FLOAT16,
26196 .zeroPoint = 0
26197 }, { // placeholder158
26198 .channelQuant = {},
26199 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
26200 .dimensions = {1},
26201 .isIgnored = false,
26202 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26203 .numberOfConsumers = 1,
26204 .scale = 0.0f,
26205 .type = TestOperandType::TENSOR_FLOAT16,
26206 .zeroPoint = 0
26207 }, { // param176
26208 .channelQuant = {},
26209 .data = TestBuffer::createFromVector<int32_t>({0}),
26210 .dimensions = {},
26211 .isIgnored = false,
26212 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26213 .numberOfConsumers = 1,
26214 .scale = 0.0f,
26215 .type = TestOperandType::INT32,
26216 .zeroPoint = 0
26217 }},
26218 .operations = {{
26219 .inputs = {4, 5, 6},
26220 .outputs = {0},
26221 .type = TestOperationType::ADD
26222 }, {
26223 .inputs = {0, 1, 2},
26224 .outputs = {3},
26225 .type = TestOperationType::SOFTMAX
26226 }},
26227 .outputIndexes = {3}
26228 },
26229 .minSupportedVersion = TestHalVersion::V1_2,
26230 .referenced = {}
26231 };
26232 return model;
26233 }
26234
26235 const auto dummy_test_model_axis_float16_dim2_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0_all_inputs_as_internal_2", get_test_model_axis_float16_dim2_axis0_all_inputs_as_internal_2());
26236
26237 } // namespace generated_tests::softmax_v1_2
26238
26239 namespace generated_tests::softmax_v1_2 {
26240
get_test_model_axis_float16_dim2_axis0_neg_2()26241 const TestModel& get_test_model_axis_float16_dim2_axis0_neg_2() {
26242 static TestModel model = {
26243 .expectFailure = false,
26244 .expectedMultinomialDistributionTolerance = 0,
26245 .isRelaxed = false,
26246 .main = { // axis
26247 .inputIndexes = {0},
26248 .operands = {{ // op1
26249 .channelQuant = {},
26250 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
26251 .dimensions = {5, 2},
26252 .isIgnored = false,
26253 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26254 .numberOfConsumers = 1,
26255 .scale = 0.0f,
26256 .type = TestOperandType::TENSOR_FLOAT16,
26257 .zeroPoint = 0
26258 }, { // param3
26259 .channelQuant = {},
26260 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26261 .dimensions = {},
26262 .isIgnored = false,
26263 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26264 .numberOfConsumers = 1,
26265 .scale = 0.0f,
26266 .type = TestOperandType::FLOAT16,
26267 .zeroPoint = 0
26268 }, { // axis
26269 .channelQuant = {},
26270 .data = TestBuffer::createFromVector<int32_t>({-2}),
26271 .dimensions = {},
26272 .isIgnored = false,
26273 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26274 .numberOfConsumers = 1,
26275 .scale = 0.0f,
26276 .type = TestOperandType::INT32,
26277 .zeroPoint = 0
26278 }, { // op2
26279 .channelQuant = {},
26280 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26281 .dimensions = {5, 2},
26282 .isIgnored = false,
26283 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26284 .numberOfConsumers = 0,
26285 .scale = 0.0f,
26286 .type = TestOperandType::TENSOR_FLOAT16,
26287 .zeroPoint = 0
26288 }},
26289 .operations = {{
26290 .inputs = {0, 1, 2},
26291 .outputs = {3},
26292 .type = TestOperationType::SOFTMAX
26293 }},
26294 .outputIndexes = {3}
26295 },
26296 .minSupportedVersion = TestHalVersion::V1_2,
26297 .referenced = {}
26298 };
26299 return model;
26300 }
26301
26302 const auto dummy_test_model_axis_float16_dim2_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0_neg_2", get_test_model_axis_float16_dim2_axis0_neg_2());
26303
26304 } // namespace generated_tests::softmax_v1_2
26305
26306 namespace generated_tests::softmax_v1_2 {
26307
get_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal_2()26308 const TestModel& get_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal_2() {
26309 static TestModel model = {
26310 .expectFailure = false,
26311 .expectedMultinomialDistributionTolerance = 0,
26312 .isRelaxed = false,
26313 .main = { // axis
26314 .inputIndexes = {4},
26315 .operands = {{ // op1
26316 .channelQuant = {},
26317 .data = TestBuffer::createFromVector<_Float16>({}),
26318 .dimensions = {5, 2},
26319 .isIgnored = false,
26320 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
26321 .numberOfConsumers = 1,
26322 .scale = 0.0f,
26323 .type = TestOperandType::TENSOR_FLOAT16,
26324 .zeroPoint = 0
26325 }, { // param3
26326 .channelQuant = {},
26327 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26328 .dimensions = {},
26329 .isIgnored = false,
26330 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26331 .numberOfConsumers = 1,
26332 .scale = 0.0f,
26333 .type = TestOperandType::FLOAT16,
26334 .zeroPoint = 0
26335 }, { // axis
26336 .channelQuant = {},
26337 .data = TestBuffer::createFromVector<int32_t>({-2}),
26338 .dimensions = {},
26339 .isIgnored = false,
26340 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26341 .numberOfConsumers = 1,
26342 .scale = 0.0f,
26343 .type = TestOperandType::INT32,
26344 .zeroPoint = 0
26345 }, { // op2
26346 .channelQuant = {},
26347 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26348 .dimensions = {5, 2},
26349 .isIgnored = false,
26350 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26351 .numberOfConsumers = 0,
26352 .scale = 0.0f,
26353 .type = TestOperandType::TENSOR_FLOAT16,
26354 .zeroPoint = 0
26355 }, { // op1_new
26356 .channelQuant = {},
26357 .data = TestBuffer::createFromVector<_Float16>({1.0f, -1.0f, 2.0f, -2.0f, 3.0f, -3.0f, 4.0f, -4.0f, 5.0f, -5.0f}),
26358 .dimensions = {5, 2},
26359 .isIgnored = false,
26360 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26361 .numberOfConsumers = 1,
26362 .scale = 0.0f,
26363 .type = TestOperandType::TENSOR_FLOAT16,
26364 .zeroPoint = 0
26365 }, { // placeholder159
26366 .channelQuant = {},
26367 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
26368 .dimensions = {1},
26369 .isIgnored = false,
26370 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26371 .numberOfConsumers = 1,
26372 .scale = 0.0f,
26373 .type = TestOperandType::TENSOR_FLOAT16,
26374 .zeroPoint = 0
26375 }, { // param177
26376 .channelQuant = {},
26377 .data = TestBuffer::createFromVector<int32_t>({0}),
26378 .dimensions = {},
26379 .isIgnored = false,
26380 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26381 .numberOfConsumers = 1,
26382 .scale = 0.0f,
26383 .type = TestOperandType::INT32,
26384 .zeroPoint = 0
26385 }},
26386 .operations = {{
26387 .inputs = {4, 5, 6},
26388 .outputs = {0},
26389 .type = TestOperationType::ADD
26390 }, {
26391 .inputs = {0, 1, 2},
26392 .outputs = {3},
26393 .type = TestOperationType::SOFTMAX
26394 }},
26395 .outputIndexes = {3}
26396 },
26397 .minSupportedVersion = TestHalVersion::V1_2,
26398 .referenced = {}
26399 };
26400 return model;
26401 }
26402
26403 const auto dummy_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim2_axis0_neg_all_inputs_as_internal_2());
26404
26405 } // namespace generated_tests::softmax_v1_2
26406
26407 namespace generated_tests::softmax_v1_2 {
26408
get_test_model_axis_float16_dim2_axis1_2()26409 const TestModel& get_test_model_axis_float16_dim2_axis1_2() {
26410 static TestModel model = {
26411 .expectFailure = false,
26412 .expectedMultinomialDistributionTolerance = 0,
26413 .isRelaxed = false,
26414 .main = { // axis
26415 .inputIndexes = {0},
26416 .operands = {{ // op1
26417 .channelQuant = {},
26418 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
26419 .dimensions = {2, 5},
26420 .isIgnored = false,
26421 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26422 .numberOfConsumers = 1,
26423 .scale = 0.0f,
26424 .type = TestOperandType::TENSOR_FLOAT16,
26425 .zeroPoint = 0
26426 }, { // param3
26427 .channelQuant = {},
26428 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26429 .dimensions = {},
26430 .isIgnored = false,
26431 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26432 .numberOfConsumers = 1,
26433 .scale = 0.0f,
26434 .type = TestOperandType::FLOAT16,
26435 .zeroPoint = 0
26436 }, { // axis
26437 .channelQuant = {},
26438 .data = TestBuffer::createFromVector<int32_t>({1}),
26439 .dimensions = {},
26440 .isIgnored = false,
26441 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26442 .numberOfConsumers = 1,
26443 .scale = 0.0f,
26444 .type = TestOperandType::INT32,
26445 .zeroPoint = 0
26446 }, { // op2
26447 .channelQuant = {},
26448 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26449 .dimensions = {2, 5},
26450 .isIgnored = false,
26451 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26452 .numberOfConsumers = 0,
26453 .scale = 0.0f,
26454 .type = TestOperandType::TENSOR_FLOAT16,
26455 .zeroPoint = 0
26456 }},
26457 .operations = {{
26458 .inputs = {0, 1, 2},
26459 .outputs = {3},
26460 .type = TestOperationType::SOFTMAX
26461 }},
26462 .outputIndexes = {3}
26463 },
26464 .minSupportedVersion = TestHalVersion::V1_2,
26465 .referenced = {}
26466 };
26467 return model;
26468 }
26469
26470 const auto dummy_test_model_axis_float16_dim2_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1_2", get_test_model_axis_float16_dim2_axis1_2());
26471
26472 } // namespace generated_tests::softmax_v1_2
26473
26474 namespace generated_tests::softmax_v1_2 {
26475
get_test_model_axis_float16_dim2_axis1_all_inputs_as_internal_2()26476 const TestModel& get_test_model_axis_float16_dim2_axis1_all_inputs_as_internal_2() {
26477 static TestModel model = {
26478 .expectFailure = false,
26479 .expectedMultinomialDistributionTolerance = 0,
26480 .isRelaxed = false,
26481 .main = { // axis
26482 .inputIndexes = {4},
26483 .operands = {{ // op1
26484 .channelQuant = {},
26485 .data = TestBuffer::createFromVector<_Float16>({}),
26486 .dimensions = {2, 5},
26487 .isIgnored = false,
26488 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
26489 .numberOfConsumers = 1,
26490 .scale = 0.0f,
26491 .type = TestOperandType::TENSOR_FLOAT16,
26492 .zeroPoint = 0
26493 }, { // param3
26494 .channelQuant = {},
26495 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26496 .dimensions = {},
26497 .isIgnored = false,
26498 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26499 .numberOfConsumers = 1,
26500 .scale = 0.0f,
26501 .type = TestOperandType::FLOAT16,
26502 .zeroPoint = 0
26503 }, { // axis
26504 .channelQuant = {},
26505 .data = TestBuffer::createFromVector<int32_t>({1}),
26506 .dimensions = {},
26507 .isIgnored = false,
26508 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26509 .numberOfConsumers = 1,
26510 .scale = 0.0f,
26511 .type = TestOperandType::INT32,
26512 .zeroPoint = 0
26513 }, { // op2
26514 .channelQuant = {},
26515 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26516 .dimensions = {2, 5},
26517 .isIgnored = false,
26518 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26519 .numberOfConsumers = 0,
26520 .scale = 0.0f,
26521 .type = TestOperandType::TENSOR_FLOAT16,
26522 .zeroPoint = 0
26523 }, { // op1_new
26524 .channelQuant = {},
26525 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
26526 .dimensions = {2, 5},
26527 .isIgnored = false,
26528 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26529 .numberOfConsumers = 1,
26530 .scale = 0.0f,
26531 .type = TestOperandType::TENSOR_FLOAT16,
26532 .zeroPoint = 0
26533 }, { // placeholder160
26534 .channelQuant = {},
26535 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
26536 .dimensions = {1},
26537 .isIgnored = false,
26538 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26539 .numberOfConsumers = 1,
26540 .scale = 0.0f,
26541 .type = TestOperandType::TENSOR_FLOAT16,
26542 .zeroPoint = 0
26543 }, { // param178
26544 .channelQuant = {},
26545 .data = TestBuffer::createFromVector<int32_t>({0}),
26546 .dimensions = {},
26547 .isIgnored = false,
26548 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26549 .numberOfConsumers = 1,
26550 .scale = 0.0f,
26551 .type = TestOperandType::INT32,
26552 .zeroPoint = 0
26553 }},
26554 .operations = {{
26555 .inputs = {4, 5, 6},
26556 .outputs = {0},
26557 .type = TestOperationType::ADD
26558 }, {
26559 .inputs = {0, 1, 2},
26560 .outputs = {3},
26561 .type = TestOperationType::SOFTMAX
26562 }},
26563 .outputIndexes = {3}
26564 },
26565 .minSupportedVersion = TestHalVersion::V1_2,
26566 .referenced = {}
26567 };
26568 return model;
26569 }
26570
26571 const auto dummy_test_model_axis_float16_dim2_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1_all_inputs_as_internal_2", get_test_model_axis_float16_dim2_axis1_all_inputs_as_internal_2());
26572
26573 } // namespace generated_tests::softmax_v1_2
26574
26575 namespace generated_tests::softmax_v1_2 {
26576
get_test_model_axis_float16_dim2_axis1_neg_2()26577 const TestModel& get_test_model_axis_float16_dim2_axis1_neg_2() {
26578 static TestModel model = {
26579 .expectFailure = false,
26580 .expectedMultinomialDistributionTolerance = 0,
26581 .isRelaxed = false,
26582 .main = { // axis
26583 .inputIndexes = {0},
26584 .operands = {{ // op1
26585 .channelQuant = {},
26586 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
26587 .dimensions = {2, 5},
26588 .isIgnored = false,
26589 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26590 .numberOfConsumers = 1,
26591 .scale = 0.0f,
26592 .type = TestOperandType::TENSOR_FLOAT16,
26593 .zeroPoint = 0
26594 }, { // param3
26595 .channelQuant = {},
26596 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26597 .dimensions = {},
26598 .isIgnored = false,
26599 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26600 .numberOfConsumers = 1,
26601 .scale = 0.0f,
26602 .type = TestOperandType::FLOAT16,
26603 .zeroPoint = 0
26604 }, { // axis
26605 .channelQuant = {},
26606 .data = TestBuffer::createFromVector<int32_t>({-1}),
26607 .dimensions = {},
26608 .isIgnored = false,
26609 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26610 .numberOfConsumers = 1,
26611 .scale = 0.0f,
26612 .type = TestOperandType::INT32,
26613 .zeroPoint = 0
26614 }, { // op2
26615 .channelQuant = {},
26616 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26617 .dimensions = {2, 5},
26618 .isIgnored = false,
26619 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26620 .numberOfConsumers = 0,
26621 .scale = 0.0f,
26622 .type = TestOperandType::TENSOR_FLOAT16,
26623 .zeroPoint = 0
26624 }},
26625 .operations = {{
26626 .inputs = {0, 1, 2},
26627 .outputs = {3},
26628 .type = TestOperationType::SOFTMAX
26629 }},
26630 .outputIndexes = {3}
26631 },
26632 .minSupportedVersion = TestHalVersion::V1_2,
26633 .referenced = {}
26634 };
26635 return model;
26636 }
26637
26638 const auto dummy_test_model_axis_float16_dim2_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1_neg_2", get_test_model_axis_float16_dim2_axis1_neg_2());
26639
26640 } // namespace generated_tests::softmax_v1_2
26641
26642 namespace generated_tests::softmax_v1_2 {
26643
get_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal_2()26644 const TestModel& get_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal_2() {
26645 static TestModel model = {
26646 .expectFailure = false,
26647 .expectedMultinomialDistributionTolerance = 0,
26648 .isRelaxed = false,
26649 .main = { // axis
26650 .inputIndexes = {4},
26651 .operands = {{ // op1
26652 .channelQuant = {},
26653 .data = TestBuffer::createFromVector<_Float16>({}),
26654 .dimensions = {2, 5},
26655 .isIgnored = false,
26656 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
26657 .numberOfConsumers = 1,
26658 .scale = 0.0f,
26659 .type = TestOperandType::TENSOR_FLOAT16,
26660 .zeroPoint = 0
26661 }, { // param3
26662 .channelQuant = {},
26663 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26664 .dimensions = {},
26665 .isIgnored = false,
26666 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26667 .numberOfConsumers = 1,
26668 .scale = 0.0f,
26669 .type = TestOperandType::FLOAT16,
26670 .zeroPoint = 0
26671 }, { // axis
26672 .channelQuant = {},
26673 .data = TestBuffer::createFromVector<int32_t>({-1}),
26674 .dimensions = {},
26675 .isIgnored = false,
26676 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26677 .numberOfConsumers = 1,
26678 .scale = 0.0f,
26679 .type = TestOperandType::INT32,
26680 .zeroPoint = 0
26681 }, { // op2
26682 .channelQuant = {},
26683 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26684 .dimensions = {2, 5},
26685 .isIgnored = false,
26686 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26687 .numberOfConsumers = 0,
26688 .scale = 0.0f,
26689 .type = TestOperandType::TENSOR_FLOAT16,
26690 .zeroPoint = 0
26691 }, { // op1_new
26692 .channelQuant = {},
26693 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, -1.0f, -2.0f, -3.0f, -4.0f, -5.0f}),
26694 .dimensions = {2, 5},
26695 .isIgnored = false,
26696 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26697 .numberOfConsumers = 1,
26698 .scale = 0.0f,
26699 .type = TestOperandType::TENSOR_FLOAT16,
26700 .zeroPoint = 0
26701 }, { // placeholder161
26702 .channelQuant = {},
26703 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
26704 .dimensions = {1},
26705 .isIgnored = false,
26706 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26707 .numberOfConsumers = 1,
26708 .scale = 0.0f,
26709 .type = TestOperandType::TENSOR_FLOAT16,
26710 .zeroPoint = 0
26711 }, { // param179
26712 .channelQuant = {},
26713 .data = TestBuffer::createFromVector<int32_t>({0}),
26714 .dimensions = {},
26715 .isIgnored = false,
26716 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26717 .numberOfConsumers = 1,
26718 .scale = 0.0f,
26719 .type = TestOperandType::INT32,
26720 .zeroPoint = 0
26721 }},
26722 .operations = {{
26723 .inputs = {4, 5, 6},
26724 .outputs = {0},
26725 .type = TestOperationType::ADD
26726 }, {
26727 .inputs = {0, 1, 2},
26728 .outputs = {3},
26729 .type = TestOperationType::SOFTMAX
26730 }},
26731 .outputIndexes = {3}
26732 },
26733 .minSupportedVersion = TestHalVersion::V1_2,
26734 .referenced = {}
26735 };
26736 return model;
26737 }
26738
26739 const auto dummy_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim2_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim2_axis1_neg_all_inputs_as_internal_2());
26740
26741 } // namespace generated_tests::softmax_v1_2
26742
26743 namespace generated_tests::softmax_v1_2 {
26744
get_test_model_axis_float16_dim1_axis0_2()26745 const TestModel& get_test_model_axis_float16_dim1_axis0_2() {
26746 static TestModel model = {
26747 .expectFailure = false,
26748 .expectedMultinomialDistributionTolerance = 0,
26749 .isRelaxed = false,
26750 .main = { // axis
26751 .inputIndexes = {0},
26752 .operands = {{ // op1
26753 .channelQuant = {},
26754 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
26755 .dimensions = {5},
26756 .isIgnored = false,
26757 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26758 .numberOfConsumers = 1,
26759 .scale = 0.0f,
26760 .type = TestOperandType::TENSOR_FLOAT16,
26761 .zeroPoint = 0
26762 }, { // param3
26763 .channelQuant = {},
26764 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26765 .dimensions = {},
26766 .isIgnored = false,
26767 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26768 .numberOfConsumers = 1,
26769 .scale = 0.0f,
26770 .type = TestOperandType::FLOAT16,
26771 .zeroPoint = 0
26772 }, { // axis
26773 .channelQuant = {},
26774 .data = TestBuffer::createFromVector<int32_t>({0}),
26775 .dimensions = {},
26776 .isIgnored = false,
26777 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26778 .numberOfConsumers = 1,
26779 .scale = 0.0f,
26780 .type = TestOperandType::INT32,
26781 .zeroPoint = 0
26782 }, { // op2
26783 .channelQuant = {},
26784 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26785 .dimensions = {5},
26786 .isIgnored = false,
26787 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26788 .numberOfConsumers = 0,
26789 .scale = 0.0f,
26790 .type = TestOperandType::TENSOR_FLOAT16,
26791 .zeroPoint = 0
26792 }},
26793 .operations = {{
26794 .inputs = {0, 1, 2},
26795 .outputs = {3},
26796 .type = TestOperationType::SOFTMAX
26797 }},
26798 .outputIndexes = {3}
26799 },
26800 .minSupportedVersion = TestHalVersion::V1_2,
26801 .referenced = {}
26802 };
26803 return model;
26804 }
26805
26806 const auto dummy_test_model_axis_float16_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0_2", get_test_model_axis_float16_dim1_axis0_2());
26807
26808 } // namespace generated_tests::softmax_v1_2
26809
26810 namespace generated_tests::softmax_v1_2 {
26811
get_test_model_axis_float16_dim1_axis0_all_inputs_as_internal_2()26812 const TestModel& get_test_model_axis_float16_dim1_axis0_all_inputs_as_internal_2() {
26813 static TestModel model = {
26814 .expectFailure = false,
26815 .expectedMultinomialDistributionTolerance = 0,
26816 .isRelaxed = false,
26817 .main = { // axis
26818 .inputIndexes = {4},
26819 .operands = {{ // op1
26820 .channelQuant = {},
26821 .data = TestBuffer::createFromVector<_Float16>({}),
26822 .dimensions = {5},
26823 .isIgnored = false,
26824 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
26825 .numberOfConsumers = 1,
26826 .scale = 0.0f,
26827 .type = TestOperandType::TENSOR_FLOAT16,
26828 .zeroPoint = 0
26829 }, { // param3
26830 .channelQuant = {},
26831 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26832 .dimensions = {},
26833 .isIgnored = false,
26834 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26835 .numberOfConsumers = 1,
26836 .scale = 0.0f,
26837 .type = TestOperandType::FLOAT16,
26838 .zeroPoint = 0
26839 }, { // axis
26840 .channelQuant = {},
26841 .data = TestBuffer::createFromVector<int32_t>({0}),
26842 .dimensions = {},
26843 .isIgnored = false,
26844 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26845 .numberOfConsumers = 1,
26846 .scale = 0.0f,
26847 .type = TestOperandType::INT32,
26848 .zeroPoint = 0
26849 }, { // op2
26850 .channelQuant = {},
26851 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26852 .dimensions = {5},
26853 .isIgnored = false,
26854 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26855 .numberOfConsumers = 0,
26856 .scale = 0.0f,
26857 .type = TestOperandType::TENSOR_FLOAT16,
26858 .zeroPoint = 0
26859 }, { // op1_new
26860 .channelQuant = {},
26861 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
26862 .dimensions = {5},
26863 .isIgnored = false,
26864 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26865 .numberOfConsumers = 1,
26866 .scale = 0.0f,
26867 .type = TestOperandType::TENSOR_FLOAT16,
26868 .zeroPoint = 0
26869 }, { // placeholder162
26870 .channelQuant = {},
26871 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
26872 .dimensions = {1},
26873 .isIgnored = false,
26874 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26875 .numberOfConsumers = 1,
26876 .scale = 0.0f,
26877 .type = TestOperandType::TENSOR_FLOAT16,
26878 .zeroPoint = 0
26879 }, { // param180
26880 .channelQuant = {},
26881 .data = TestBuffer::createFromVector<int32_t>({0}),
26882 .dimensions = {},
26883 .isIgnored = false,
26884 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26885 .numberOfConsumers = 1,
26886 .scale = 0.0f,
26887 .type = TestOperandType::INT32,
26888 .zeroPoint = 0
26889 }},
26890 .operations = {{
26891 .inputs = {4, 5, 6},
26892 .outputs = {0},
26893 .type = TestOperationType::ADD
26894 }, {
26895 .inputs = {0, 1, 2},
26896 .outputs = {3},
26897 .type = TestOperationType::SOFTMAX
26898 }},
26899 .outputIndexes = {3}
26900 },
26901 .minSupportedVersion = TestHalVersion::V1_2,
26902 .referenced = {}
26903 };
26904 return model;
26905 }
26906
26907 const auto dummy_test_model_axis_float16_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0_all_inputs_as_internal_2", get_test_model_axis_float16_dim1_axis0_all_inputs_as_internal_2());
26908
26909 } // namespace generated_tests::softmax_v1_2
26910
26911 namespace generated_tests::softmax_v1_2 {
26912
get_test_model_axis_float16_dim1_axis0_neg_2()26913 const TestModel& get_test_model_axis_float16_dim1_axis0_neg_2() {
26914 static TestModel model = {
26915 .expectFailure = false,
26916 .expectedMultinomialDistributionTolerance = 0,
26917 .isRelaxed = false,
26918 .main = { // axis
26919 .inputIndexes = {0},
26920 .operands = {{ // op1
26921 .channelQuant = {},
26922 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
26923 .dimensions = {5},
26924 .isIgnored = false,
26925 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
26926 .numberOfConsumers = 1,
26927 .scale = 0.0f,
26928 .type = TestOperandType::TENSOR_FLOAT16,
26929 .zeroPoint = 0
26930 }, { // param3
26931 .channelQuant = {},
26932 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
26933 .dimensions = {},
26934 .isIgnored = false,
26935 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26936 .numberOfConsumers = 1,
26937 .scale = 0.0f,
26938 .type = TestOperandType::FLOAT16,
26939 .zeroPoint = 0
26940 }, { // axis
26941 .channelQuant = {},
26942 .data = TestBuffer::createFromVector<int32_t>({-1}),
26943 .dimensions = {},
26944 .isIgnored = false,
26945 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
26946 .numberOfConsumers = 1,
26947 .scale = 0.0f,
26948 .type = TestOperandType::INT32,
26949 .zeroPoint = 0
26950 }, { // op2
26951 .channelQuant = {},
26952 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
26953 .dimensions = {5},
26954 .isIgnored = false,
26955 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
26956 .numberOfConsumers = 0,
26957 .scale = 0.0f,
26958 .type = TestOperandType::TENSOR_FLOAT16,
26959 .zeroPoint = 0
26960 }},
26961 .operations = {{
26962 .inputs = {0, 1, 2},
26963 .outputs = {3},
26964 .type = TestOperationType::SOFTMAX
26965 }},
26966 .outputIndexes = {3}
26967 },
26968 .minSupportedVersion = TestHalVersion::V1_2,
26969 .referenced = {}
26970 };
26971 return model;
26972 }
26973
26974 const auto dummy_test_model_axis_float16_dim1_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0_neg_2", get_test_model_axis_float16_dim1_axis0_neg_2());
26975
26976 } // namespace generated_tests::softmax_v1_2
26977
26978 namespace generated_tests::softmax_v1_2 {
26979
get_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal_2()26980 const TestModel& get_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal_2() {
26981 static TestModel model = {
26982 .expectFailure = false,
26983 .expectedMultinomialDistributionTolerance = 0,
26984 .isRelaxed = false,
26985 .main = { // axis
26986 .inputIndexes = {4},
26987 .operands = {{ // op1
26988 .channelQuant = {},
26989 .data = TestBuffer::createFromVector<_Float16>({}),
26990 .dimensions = {5},
26991 .isIgnored = false,
26992 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
26993 .numberOfConsumers = 1,
26994 .scale = 0.0f,
26995 .type = TestOperandType::TENSOR_FLOAT16,
26996 .zeroPoint = 0
26997 }, { // param3
26998 .channelQuant = {},
26999 .data = TestBuffer::createFromVector<_Float16>({9.999999974752427e-07f}),
27000 .dimensions = {},
27001 .isIgnored = false,
27002 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27003 .numberOfConsumers = 1,
27004 .scale = 0.0f,
27005 .type = TestOperandType::FLOAT16,
27006 .zeroPoint = 0
27007 }, { // axis
27008 .channelQuant = {},
27009 .data = TestBuffer::createFromVector<int32_t>({-1}),
27010 .dimensions = {},
27011 .isIgnored = false,
27012 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27013 .numberOfConsumers = 1,
27014 .scale = 0.0f,
27015 .type = TestOperandType::INT32,
27016 .zeroPoint = 0
27017 }, { // op2
27018 .channelQuant = {},
27019 .data = TestBuffer::createFromVector<_Float16>({0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f, 0.20000000298023224f}),
27020 .dimensions = {5},
27021 .isIgnored = false,
27022 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27023 .numberOfConsumers = 0,
27024 .scale = 0.0f,
27025 .type = TestOperandType::TENSOR_FLOAT16,
27026 .zeroPoint = 0
27027 }, { // op1_new
27028 .channelQuant = {},
27029 .data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f}),
27030 .dimensions = {5},
27031 .isIgnored = false,
27032 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27033 .numberOfConsumers = 1,
27034 .scale = 0.0f,
27035 .type = TestOperandType::TENSOR_FLOAT16,
27036 .zeroPoint = 0
27037 }, { // placeholder163
27038 .channelQuant = {},
27039 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
27040 .dimensions = {1},
27041 .isIgnored = false,
27042 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27043 .numberOfConsumers = 1,
27044 .scale = 0.0f,
27045 .type = TestOperandType::TENSOR_FLOAT16,
27046 .zeroPoint = 0
27047 }, { // param181
27048 .channelQuant = {},
27049 .data = TestBuffer::createFromVector<int32_t>({0}),
27050 .dimensions = {},
27051 .isIgnored = false,
27052 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27053 .numberOfConsumers = 1,
27054 .scale = 0.0f,
27055 .type = TestOperandType::INT32,
27056 .zeroPoint = 0
27057 }},
27058 .operations = {{
27059 .inputs = {4, 5, 6},
27060 .outputs = {0},
27061 .type = TestOperationType::ADD
27062 }, {
27063 .inputs = {0, 1, 2},
27064 .outputs = {3},
27065 .type = TestOperationType::SOFTMAX
27066 }},
27067 .outputIndexes = {3}
27068 },
27069 .minSupportedVersion = TestHalVersion::V1_2,
27070 .referenced = {}
27071 };
27072 return model;
27073 }
27074
27075 const auto dummy_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_float16_dim1_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_float16_dim1_axis0_neg_all_inputs_as_internal_2());
27076
27077 } // namespace generated_tests::softmax_v1_2
27078
27079 namespace generated_tests::softmax_v1_2 {
27080
get_test_model_axis_quant8_dim4_axis0_2()27081 const TestModel& get_test_model_axis_quant8_dim4_axis0_2() {
27082 static TestModel model = {
27083 .expectFailure = false,
27084 .expectedMultinomialDistributionTolerance = 0,
27085 .isRelaxed = false,
27086 .main = { // axis
27087 .inputIndexes = {0},
27088 .operands = {{ // op1
27089 .channelQuant = {},
27090 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 132, 124, 132, 124, 136, 120, 136, 120, 136, 120, 136, 120, 140, 116, 140, 116, 140, 116, 140, 116, 144, 112, 144, 112, 144, 112, 144, 112, 148, 108, 148, 108, 148, 108, 148, 108}),
27091 .dimensions = {5, 2, 2, 2},
27092 .isIgnored = false,
27093 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27094 .numberOfConsumers = 1,
27095 .scale = 0.25f,
27096 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27097 .zeroPoint = 128
27098 }, { // param3
27099 .channelQuant = {},
27100 .data = TestBuffer::createFromVector<float>({1e-06f}),
27101 .dimensions = {},
27102 .isIgnored = false,
27103 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27104 .numberOfConsumers = 1,
27105 .scale = 0.0f,
27106 .type = TestOperandType::FLOAT32,
27107 .zeroPoint = 0
27108 }, { // axis
27109 .channelQuant = {},
27110 .data = TestBuffer::createFromVector<int32_t>({0}),
27111 .dimensions = {},
27112 .isIgnored = false,
27113 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27114 .numberOfConsumers = 1,
27115 .scale = 0.0f,
27116 .type = TestOperandType::INT32,
27117 .zeroPoint = 0
27118 }, { // op2
27119 .channelQuant = {},
27120 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27121 .dimensions = {5, 2, 2, 2},
27122 .isIgnored = false,
27123 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27124 .numberOfConsumers = 0,
27125 .scale = 0.00390625f,
27126 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27127 .zeroPoint = 0
27128 }},
27129 .operations = {{
27130 .inputs = {0, 1, 2},
27131 .outputs = {3},
27132 .type = TestOperationType::SOFTMAX
27133 }},
27134 .outputIndexes = {3}
27135 },
27136 .minSupportedVersion = TestHalVersion::V1_2,
27137 .referenced = {}
27138 };
27139 return model;
27140 }
27141
27142 const auto dummy_test_model_axis_quant8_dim4_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0_2", get_test_model_axis_quant8_dim4_axis0_2());
27143
27144 } // namespace generated_tests::softmax_v1_2
27145
27146 namespace generated_tests::softmax_v1_2 {
27147
get_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal_2()27148 const TestModel& get_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal_2() {
27149 static TestModel model = {
27150 .expectFailure = false,
27151 .expectedMultinomialDistributionTolerance = 0,
27152 .isRelaxed = false,
27153 .main = { // axis
27154 .inputIndexes = {4},
27155 .operands = {{ // op1
27156 .channelQuant = {},
27157 .data = TestBuffer::createFromVector<uint8_t>({}),
27158 .dimensions = {5, 2, 2, 2},
27159 .isIgnored = false,
27160 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
27161 .numberOfConsumers = 1,
27162 .scale = 0.25f,
27163 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27164 .zeroPoint = 128
27165 }, { // param3
27166 .channelQuant = {},
27167 .data = TestBuffer::createFromVector<float>({1e-06f}),
27168 .dimensions = {},
27169 .isIgnored = false,
27170 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27171 .numberOfConsumers = 1,
27172 .scale = 0.0f,
27173 .type = TestOperandType::FLOAT32,
27174 .zeroPoint = 0
27175 }, { // axis
27176 .channelQuant = {},
27177 .data = TestBuffer::createFromVector<int32_t>({0}),
27178 .dimensions = {},
27179 .isIgnored = false,
27180 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27181 .numberOfConsumers = 1,
27182 .scale = 0.0f,
27183 .type = TestOperandType::INT32,
27184 .zeroPoint = 0
27185 }, { // op2
27186 .channelQuant = {},
27187 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27188 .dimensions = {5, 2, 2, 2},
27189 .isIgnored = false,
27190 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27191 .numberOfConsumers = 0,
27192 .scale = 0.00390625f,
27193 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27194 .zeroPoint = 0
27195 }, { // op1_new
27196 .channelQuant = {},
27197 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 132, 124, 132, 124, 136, 120, 136, 120, 136, 120, 136, 120, 140, 116, 140, 116, 140, 116, 140, 116, 144, 112, 144, 112, 144, 112, 144, 112, 148, 108, 148, 108, 148, 108, 148, 108}),
27198 .dimensions = {5, 2, 2, 2},
27199 .isIgnored = false,
27200 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27201 .numberOfConsumers = 1,
27202 .scale = 0.25f,
27203 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27204 .zeroPoint = 128
27205 }, { // placeholder164
27206 .channelQuant = {},
27207 .data = TestBuffer::createFromVector<uint8_t>({128}),
27208 .dimensions = {1},
27209 .isIgnored = false,
27210 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27211 .numberOfConsumers = 1,
27212 .scale = 0.25f,
27213 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27214 .zeroPoint = 128
27215 }, { // param182
27216 .channelQuant = {},
27217 .data = TestBuffer::createFromVector<int32_t>({0}),
27218 .dimensions = {},
27219 .isIgnored = false,
27220 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27221 .numberOfConsumers = 1,
27222 .scale = 0.0f,
27223 .type = TestOperandType::INT32,
27224 .zeroPoint = 0
27225 }},
27226 .operations = {{
27227 .inputs = {4, 5, 6},
27228 .outputs = {0},
27229 .type = TestOperationType::ADD
27230 }, {
27231 .inputs = {0, 1, 2},
27232 .outputs = {3},
27233 .type = TestOperationType::SOFTMAX
27234 }},
27235 .outputIndexes = {3}
27236 },
27237 .minSupportedVersion = TestHalVersion::V1_2,
27238 .referenced = {}
27239 };
27240 return model;
27241 }
27242
27243 const auto dummy_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis0_all_inputs_as_internal_2());
27244
27245 } // namespace generated_tests::softmax_v1_2
27246
27247 namespace generated_tests::softmax_v1_2 {
27248
get_test_model_axis_quant8_dim4_axis0_neg_2()27249 const TestModel& get_test_model_axis_quant8_dim4_axis0_neg_2() {
27250 static TestModel model = {
27251 .expectFailure = false,
27252 .expectedMultinomialDistributionTolerance = 0,
27253 .isRelaxed = false,
27254 .main = { // axis
27255 .inputIndexes = {0},
27256 .operands = {{ // op1
27257 .channelQuant = {},
27258 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 132, 124, 132, 124, 136, 120, 136, 120, 136, 120, 136, 120, 140, 116, 140, 116, 140, 116, 140, 116, 144, 112, 144, 112, 144, 112, 144, 112, 148, 108, 148, 108, 148, 108, 148, 108}),
27259 .dimensions = {5, 2, 2, 2},
27260 .isIgnored = false,
27261 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27262 .numberOfConsumers = 1,
27263 .scale = 0.25f,
27264 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27265 .zeroPoint = 128
27266 }, { // param3
27267 .channelQuant = {},
27268 .data = TestBuffer::createFromVector<float>({1e-06f}),
27269 .dimensions = {},
27270 .isIgnored = false,
27271 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27272 .numberOfConsumers = 1,
27273 .scale = 0.0f,
27274 .type = TestOperandType::FLOAT32,
27275 .zeroPoint = 0
27276 }, { // axis
27277 .channelQuant = {},
27278 .data = TestBuffer::createFromVector<int32_t>({-4}),
27279 .dimensions = {},
27280 .isIgnored = false,
27281 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27282 .numberOfConsumers = 1,
27283 .scale = 0.0f,
27284 .type = TestOperandType::INT32,
27285 .zeroPoint = 0
27286 }, { // op2
27287 .channelQuant = {},
27288 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27289 .dimensions = {5, 2, 2, 2},
27290 .isIgnored = false,
27291 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27292 .numberOfConsumers = 0,
27293 .scale = 0.00390625f,
27294 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27295 .zeroPoint = 0
27296 }},
27297 .operations = {{
27298 .inputs = {0, 1, 2},
27299 .outputs = {3},
27300 .type = TestOperationType::SOFTMAX
27301 }},
27302 .outputIndexes = {3}
27303 },
27304 .minSupportedVersion = TestHalVersion::V1_2,
27305 .referenced = {}
27306 };
27307 return model;
27308 }
27309
27310 const auto dummy_test_model_axis_quant8_dim4_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0_neg_2", get_test_model_axis_quant8_dim4_axis0_neg_2());
27311
27312 } // namespace generated_tests::softmax_v1_2
27313
27314 namespace generated_tests::softmax_v1_2 {
27315
get_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal_2()27316 const TestModel& get_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal_2() {
27317 static TestModel model = {
27318 .expectFailure = false,
27319 .expectedMultinomialDistributionTolerance = 0,
27320 .isRelaxed = false,
27321 .main = { // axis
27322 .inputIndexes = {4},
27323 .operands = {{ // op1
27324 .channelQuant = {},
27325 .data = TestBuffer::createFromVector<uint8_t>({}),
27326 .dimensions = {5, 2, 2, 2},
27327 .isIgnored = false,
27328 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
27329 .numberOfConsumers = 1,
27330 .scale = 0.25f,
27331 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27332 .zeroPoint = 128
27333 }, { // param3
27334 .channelQuant = {},
27335 .data = TestBuffer::createFromVector<float>({1e-06f}),
27336 .dimensions = {},
27337 .isIgnored = false,
27338 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27339 .numberOfConsumers = 1,
27340 .scale = 0.0f,
27341 .type = TestOperandType::FLOAT32,
27342 .zeroPoint = 0
27343 }, { // axis
27344 .channelQuant = {},
27345 .data = TestBuffer::createFromVector<int32_t>({-4}),
27346 .dimensions = {},
27347 .isIgnored = false,
27348 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27349 .numberOfConsumers = 1,
27350 .scale = 0.0f,
27351 .type = TestOperandType::INT32,
27352 .zeroPoint = 0
27353 }, { // op2
27354 .channelQuant = {},
27355 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27356 .dimensions = {5, 2, 2, 2},
27357 .isIgnored = false,
27358 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27359 .numberOfConsumers = 0,
27360 .scale = 0.00390625f,
27361 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27362 .zeroPoint = 0
27363 }, { // op1_new
27364 .channelQuant = {},
27365 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 132, 124, 132, 124, 136, 120, 136, 120, 136, 120, 136, 120, 140, 116, 140, 116, 140, 116, 140, 116, 144, 112, 144, 112, 144, 112, 144, 112, 148, 108, 148, 108, 148, 108, 148, 108}),
27366 .dimensions = {5, 2, 2, 2},
27367 .isIgnored = false,
27368 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27369 .numberOfConsumers = 1,
27370 .scale = 0.25f,
27371 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27372 .zeroPoint = 128
27373 }, { // placeholder165
27374 .channelQuant = {},
27375 .data = TestBuffer::createFromVector<uint8_t>({128}),
27376 .dimensions = {1},
27377 .isIgnored = false,
27378 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27379 .numberOfConsumers = 1,
27380 .scale = 0.25f,
27381 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27382 .zeroPoint = 128
27383 }, { // param183
27384 .channelQuant = {},
27385 .data = TestBuffer::createFromVector<int32_t>({0}),
27386 .dimensions = {},
27387 .isIgnored = false,
27388 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27389 .numberOfConsumers = 1,
27390 .scale = 0.0f,
27391 .type = TestOperandType::INT32,
27392 .zeroPoint = 0
27393 }},
27394 .operations = {{
27395 .inputs = {4, 5, 6},
27396 .outputs = {0},
27397 .type = TestOperationType::ADD
27398 }, {
27399 .inputs = {0, 1, 2},
27400 .outputs = {3},
27401 .type = TestOperationType::SOFTMAX
27402 }},
27403 .outputIndexes = {3}
27404 },
27405 .minSupportedVersion = TestHalVersion::V1_2,
27406 .referenced = {}
27407 };
27408 return model;
27409 }
27410
27411 const auto dummy_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis0_neg_all_inputs_as_internal_2());
27412
27413 } // namespace generated_tests::softmax_v1_2
27414
27415 namespace generated_tests::softmax_v1_2 {
27416
get_test_model_axis_quant8_dim4_axis1_2()27417 const TestModel& get_test_model_axis_quant8_dim4_axis1_2() {
27418 static TestModel model = {
27419 .expectFailure = false,
27420 .expectedMultinomialDistributionTolerance = 0,
27421 .isRelaxed = false,
27422 .main = { // axis
27423 .inputIndexes = {0},
27424 .operands = {{ // op1
27425 .channelQuant = {},
27426 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108, 132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
27427 .dimensions = {2, 5, 2, 2},
27428 .isIgnored = false,
27429 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27430 .numberOfConsumers = 1,
27431 .scale = 0.25f,
27432 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27433 .zeroPoint = 128
27434 }, { // param3
27435 .channelQuant = {},
27436 .data = TestBuffer::createFromVector<float>({1e-06f}),
27437 .dimensions = {},
27438 .isIgnored = false,
27439 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27440 .numberOfConsumers = 1,
27441 .scale = 0.0f,
27442 .type = TestOperandType::FLOAT32,
27443 .zeroPoint = 0
27444 }, { // axis
27445 .channelQuant = {},
27446 .data = TestBuffer::createFromVector<int32_t>({1}),
27447 .dimensions = {},
27448 .isIgnored = false,
27449 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27450 .numberOfConsumers = 1,
27451 .scale = 0.0f,
27452 .type = TestOperandType::INT32,
27453 .zeroPoint = 0
27454 }, { // op2
27455 .channelQuant = {},
27456 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27457 .dimensions = {2, 5, 2, 2},
27458 .isIgnored = false,
27459 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27460 .numberOfConsumers = 0,
27461 .scale = 0.00390625f,
27462 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27463 .zeroPoint = 0
27464 }},
27465 .operations = {{
27466 .inputs = {0, 1, 2},
27467 .outputs = {3},
27468 .type = TestOperationType::SOFTMAX
27469 }},
27470 .outputIndexes = {3}
27471 },
27472 .minSupportedVersion = TestHalVersion::V1_2,
27473 .referenced = {}
27474 };
27475 return model;
27476 }
27477
27478 const auto dummy_test_model_axis_quant8_dim4_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1_2", get_test_model_axis_quant8_dim4_axis1_2());
27479
27480 } // namespace generated_tests::softmax_v1_2
27481
27482 namespace generated_tests::softmax_v1_2 {
27483
get_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal_2()27484 const TestModel& get_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal_2() {
27485 static TestModel model = {
27486 .expectFailure = false,
27487 .expectedMultinomialDistributionTolerance = 0,
27488 .isRelaxed = false,
27489 .main = { // axis
27490 .inputIndexes = {4},
27491 .operands = {{ // op1
27492 .channelQuant = {},
27493 .data = TestBuffer::createFromVector<uint8_t>({}),
27494 .dimensions = {2, 5, 2, 2},
27495 .isIgnored = false,
27496 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
27497 .numberOfConsumers = 1,
27498 .scale = 0.25f,
27499 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27500 .zeroPoint = 128
27501 }, { // param3
27502 .channelQuant = {},
27503 .data = TestBuffer::createFromVector<float>({1e-06f}),
27504 .dimensions = {},
27505 .isIgnored = false,
27506 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27507 .numberOfConsumers = 1,
27508 .scale = 0.0f,
27509 .type = TestOperandType::FLOAT32,
27510 .zeroPoint = 0
27511 }, { // axis
27512 .channelQuant = {},
27513 .data = TestBuffer::createFromVector<int32_t>({1}),
27514 .dimensions = {},
27515 .isIgnored = false,
27516 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27517 .numberOfConsumers = 1,
27518 .scale = 0.0f,
27519 .type = TestOperandType::INT32,
27520 .zeroPoint = 0
27521 }, { // op2
27522 .channelQuant = {},
27523 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27524 .dimensions = {2, 5, 2, 2},
27525 .isIgnored = false,
27526 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27527 .numberOfConsumers = 0,
27528 .scale = 0.00390625f,
27529 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27530 .zeroPoint = 0
27531 }, { // op1_new
27532 .channelQuant = {},
27533 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108, 132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
27534 .dimensions = {2, 5, 2, 2},
27535 .isIgnored = false,
27536 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27537 .numberOfConsumers = 1,
27538 .scale = 0.25f,
27539 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27540 .zeroPoint = 128
27541 }, { // placeholder166
27542 .channelQuant = {},
27543 .data = TestBuffer::createFromVector<uint8_t>({128}),
27544 .dimensions = {1},
27545 .isIgnored = false,
27546 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27547 .numberOfConsumers = 1,
27548 .scale = 0.25f,
27549 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27550 .zeroPoint = 128
27551 }, { // param184
27552 .channelQuant = {},
27553 .data = TestBuffer::createFromVector<int32_t>({0}),
27554 .dimensions = {},
27555 .isIgnored = false,
27556 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27557 .numberOfConsumers = 1,
27558 .scale = 0.0f,
27559 .type = TestOperandType::INT32,
27560 .zeroPoint = 0
27561 }},
27562 .operations = {{
27563 .inputs = {4, 5, 6},
27564 .outputs = {0},
27565 .type = TestOperationType::ADD
27566 }, {
27567 .inputs = {0, 1, 2},
27568 .outputs = {3},
27569 .type = TestOperationType::SOFTMAX
27570 }},
27571 .outputIndexes = {3}
27572 },
27573 .minSupportedVersion = TestHalVersion::V1_2,
27574 .referenced = {}
27575 };
27576 return model;
27577 }
27578
27579 const auto dummy_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis1_all_inputs_as_internal_2());
27580
27581 } // namespace generated_tests::softmax_v1_2
27582
27583 namespace generated_tests::softmax_v1_2 {
27584
get_test_model_axis_quant8_dim4_axis1_neg_2()27585 const TestModel& get_test_model_axis_quant8_dim4_axis1_neg_2() {
27586 static TestModel model = {
27587 .expectFailure = false,
27588 .expectedMultinomialDistributionTolerance = 0,
27589 .isRelaxed = false,
27590 .main = { // axis
27591 .inputIndexes = {0},
27592 .operands = {{ // op1
27593 .channelQuant = {},
27594 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108, 132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
27595 .dimensions = {2, 5, 2, 2},
27596 .isIgnored = false,
27597 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27598 .numberOfConsumers = 1,
27599 .scale = 0.25f,
27600 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27601 .zeroPoint = 128
27602 }, { // param3
27603 .channelQuant = {},
27604 .data = TestBuffer::createFromVector<float>({1e-06f}),
27605 .dimensions = {},
27606 .isIgnored = false,
27607 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27608 .numberOfConsumers = 1,
27609 .scale = 0.0f,
27610 .type = TestOperandType::FLOAT32,
27611 .zeroPoint = 0
27612 }, { // axis
27613 .channelQuant = {},
27614 .data = TestBuffer::createFromVector<int32_t>({-3}),
27615 .dimensions = {},
27616 .isIgnored = false,
27617 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27618 .numberOfConsumers = 1,
27619 .scale = 0.0f,
27620 .type = TestOperandType::INT32,
27621 .zeroPoint = 0
27622 }, { // op2
27623 .channelQuant = {},
27624 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27625 .dimensions = {2, 5, 2, 2},
27626 .isIgnored = false,
27627 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27628 .numberOfConsumers = 0,
27629 .scale = 0.00390625f,
27630 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27631 .zeroPoint = 0
27632 }},
27633 .operations = {{
27634 .inputs = {0, 1, 2},
27635 .outputs = {3},
27636 .type = TestOperationType::SOFTMAX
27637 }},
27638 .outputIndexes = {3}
27639 },
27640 .minSupportedVersion = TestHalVersion::V1_2,
27641 .referenced = {}
27642 };
27643 return model;
27644 }
27645
27646 const auto dummy_test_model_axis_quant8_dim4_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1_neg_2", get_test_model_axis_quant8_dim4_axis1_neg_2());
27647
27648 } // namespace generated_tests::softmax_v1_2
27649
27650 namespace generated_tests::softmax_v1_2 {
27651
get_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal_2()27652 const TestModel& get_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal_2() {
27653 static TestModel model = {
27654 .expectFailure = false,
27655 .expectedMultinomialDistributionTolerance = 0,
27656 .isRelaxed = false,
27657 .main = { // axis
27658 .inputIndexes = {4},
27659 .operands = {{ // op1
27660 .channelQuant = {},
27661 .data = TestBuffer::createFromVector<uint8_t>({}),
27662 .dimensions = {2, 5, 2, 2},
27663 .isIgnored = false,
27664 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
27665 .numberOfConsumers = 1,
27666 .scale = 0.25f,
27667 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27668 .zeroPoint = 128
27669 }, { // param3
27670 .channelQuant = {},
27671 .data = TestBuffer::createFromVector<float>({1e-06f}),
27672 .dimensions = {},
27673 .isIgnored = false,
27674 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27675 .numberOfConsumers = 1,
27676 .scale = 0.0f,
27677 .type = TestOperandType::FLOAT32,
27678 .zeroPoint = 0
27679 }, { // axis
27680 .channelQuant = {},
27681 .data = TestBuffer::createFromVector<int32_t>({-3}),
27682 .dimensions = {},
27683 .isIgnored = false,
27684 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27685 .numberOfConsumers = 1,
27686 .scale = 0.0f,
27687 .type = TestOperandType::INT32,
27688 .zeroPoint = 0
27689 }, { // op2
27690 .channelQuant = {},
27691 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27692 .dimensions = {2, 5, 2, 2},
27693 .isIgnored = false,
27694 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27695 .numberOfConsumers = 0,
27696 .scale = 0.00390625f,
27697 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27698 .zeroPoint = 0
27699 }, { // op1_new
27700 .channelQuant = {},
27701 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108, 132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
27702 .dimensions = {2, 5, 2, 2},
27703 .isIgnored = false,
27704 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27705 .numberOfConsumers = 1,
27706 .scale = 0.25f,
27707 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27708 .zeroPoint = 128
27709 }, { // placeholder167
27710 .channelQuant = {},
27711 .data = TestBuffer::createFromVector<uint8_t>({128}),
27712 .dimensions = {1},
27713 .isIgnored = false,
27714 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27715 .numberOfConsumers = 1,
27716 .scale = 0.25f,
27717 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27718 .zeroPoint = 128
27719 }, { // param185
27720 .channelQuant = {},
27721 .data = TestBuffer::createFromVector<int32_t>({0}),
27722 .dimensions = {},
27723 .isIgnored = false,
27724 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27725 .numberOfConsumers = 1,
27726 .scale = 0.0f,
27727 .type = TestOperandType::INT32,
27728 .zeroPoint = 0
27729 }},
27730 .operations = {{
27731 .inputs = {4, 5, 6},
27732 .outputs = {0},
27733 .type = TestOperationType::ADD
27734 }, {
27735 .inputs = {0, 1, 2},
27736 .outputs = {3},
27737 .type = TestOperationType::SOFTMAX
27738 }},
27739 .outputIndexes = {3}
27740 },
27741 .minSupportedVersion = TestHalVersion::V1_2,
27742 .referenced = {}
27743 };
27744 return model;
27745 }
27746
27747 const auto dummy_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis1_neg_all_inputs_as_internal_2());
27748
27749 } // namespace generated_tests::softmax_v1_2
27750
27751 namespace generated_tests::softmax_v1_2 {
27752
get_test_model_axis_quant8_dim4_axis2_2()27753 const TestModel& get_test_model_axis_quant8_dim4_axis2_2() {
27754 static TestModel model = {
27755 .expectFailure = false,
27756 .expectedMultinomialDistributionTolerance = 0,
27757 .isRelaxed = false,
27758 .main = { // axis
27759 .inputIndexes = {0},
27760 .operands = {{ // op1
27761 .channelQuant = {},
27762 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
27763 .dimensions = {2, 2, 5, 2},
27764 .isIgnored = false,
27765 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27766 .numberOfConsumers = 1,
27767 .scale = 0.25f,
27768 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27769 .zeroPoint = 128
27770 }, { // param3
27771 .channelQuant = {},
27772 .data = TestBuffer::createFromVector<float>({1e-06f}),
27773 .dimensions = {},
27774 .isIgnored = false,
27775 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27776 .numberOfConsumers = 1,
27777 .scale = 0.0f,
27778 .type = TestOperandType::FLOAT32,
27779 .zeroPoint = 0
27780 }, { // axis
27781 .channelQuant = {},
27782 .data = TestBuffer::createFromVector<int32_t>({2}),
27783 .dimensions = {},
27784 .isIgnored = false,
27785 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27786 .numberOfConsumers = 1,
27787 .scale = 0.0f,
27788 .type = TestOperandType::INT32,
27789 .zeroPoint = 0
27790 }, { // op2
27791 .channelQuant = {},
27792 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27793 .dimensions = {2, 2, 5, 2},
27794 .isIgnored = false,
27795 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27796 .numberOfConsumers = 0,
27797 .scale = 0.00390625f,
27798 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27799 .zeroPoint = 0
27800 }},
27801 .operations = {{
27802 .inputs = {0, 1, 2},
27803 .outputs = {3},
27804 .type = TestOperationType::SOFTMAX
27805 }},
27806 .outputIndexes = {3}
27807 },
27808 .minSupportedVersion = TestHalVersion::V1_2,
27809 .referenced = {}
27810 };
27811 return model;
27812 }
27813
27814 const auto dummy_test_model_axis_quant8_dim4_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2_2", get_test_model_axis_quant8_dim4_axis2_2());
27815
27816 } // namespace generated_tests::softmax_v1_2
27817
27818 namespace generated_tests::softmax_v1_2 {
27819
get_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal_2()27820 const TestModel& get_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal_2() {
27821 static TestModel model = {
27822 .expectFailure = false,
27823 .expectedMultinomialDistributionTolerance = 0,
27824 .isRelaxed = false,
27825 .main = { // axis
27826 .inputIndexes = {4},
27827 .operands = {{ // op1
27828 .channelQuant = {},
27829 .data = TestBuffer::createFromVector<uint8_t>({}),
27830 .dimensions = {2, 2, 5, 2},
27831 .isIgnored = false,
27832 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
27833 .numberOfConsumers = 1,
27834 .scale = 0.25f,
27835 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27836 .zeroPoint = 128
27837 }, { // param3
27838 .channelQuant = {},
27839 .data = TestBuffer::createFromVector<float>({1e-06f}),
27840 .dimensions = {},
27841 .isIgnored = false,
27842 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27843 .numberOfConsumers = 1,
27844 .scale = 0.0f,
27845 .type = TestOperandType::FLOAT32,
27846 .zeroPoint = 0
27847 }, { // axis
27848 .channelQuant = {},
27849 .data = TestBuffer::createFromVector<int32_t>({2}),
27850 .dimensions = {},
27851 .isIgnored = false,
27852 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27853 .numberOfConsumers = 1,
27854 .scale = 0.0f,
27855 .type = TestOperandType::INT32,
27856 .zeroPoint = 0
27857 }, { // op2
27858 .channelQuant = {},
27859 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27860 .dimensions = {2, 2, 5, 2},
27861 .isIgnored = false,
27862 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27863 .numberOfConsumers = 0,
27864 .scale = 0.00390625f,
27865 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27866 .zeroPoint = 0
27867 }, { // op1_new
27868 .channelQuant = {},
27869 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
27870 .dimensions = {2, 2, 5, 2},
27871 .isIgnored = false,
27872 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27873 .numberOfConsumers = 1,
27874 .scale = 0.25f,
27875 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27876 .zeroPoint = 128
27877 }, { // placeholder168
27878 .channelQuant = {},
27879 .data = TestBuffer::createFromVector<uint8_t>({128}),
27880 .dimensions = {1},
27881 .isIgnored = false,
27882 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27883 .numberOfConsumers = 1,
27884 .scale = 0.25f,
27885 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27886 .zeroPoint = 128
27887 }, { // param186
27888 .channelQuant = {},
27889 .data = TestBuffer::createFromVector<int32_t>({0}),
27890 .dimensions = {},
27891 .isIgnored = false,
27892 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27893 .numberOfConsumers = 1,
27894 .scale = 0.0f,
27895 .type = TestOperandType::INT32,
27896 .zeroPoint = 0
27897 }},
27898 .operations = {{
27899 .inputs = {4, 5, 6},
27900 .outputs = {0},
27901 .type = TestOperationType::ADD
27902 }, {
27903 .inputs = {0, 1, 2},
27904 .outputs = {3},
27905 .type = TestOperationType::SOFTMAX
27906 }},
27907 .outputIndexes = {3}
27908 },
27909 .minSupportedVersion = TestHalVersion::V1_2,
27910 .referenced = {}
27911 };
27912 return model;
27913 }
27914
27915 const auto dummy_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis2_all_inputs_as_internal_2());
27916
27917 } // namespace generated_tests::softmax_v1_2
27918
27919 namespace generated_tests::softmax_v1_2 {
27920
get_test_model_axis_quant8_dim4_axis2_neg_2()27921 const TestModel& get_test_model_axis_quant8_dim4_axis2_neg_2() {
27922 static TestModel model = {
27923 .expectFailure = false,
27924 .expectedMultinomialDistributionTolerance = 0,
27925 .isRelaxed = false,
27926 .main = { // axis
27927 .inputIndexes = {0},
27928 .operands = {{ // op1
27929 .channelQuant = {},
27930 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
27931 .dimensions = {2, 2, 5, 2},
27932 .isIgnored = false,
27933 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
27934 .numberOfConsumers = 1,
27935 .scale = 0.25f,
27936 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27937 .zeroPoint = 128
27938 }, { // param3
27939 .channelQuant = {},
27940 .data = TestBuffer::createFromVector<float>({1e-06f}),
27941 .dimensions = {},
27942 .isIgnored = false,
27943 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27944 .numberOfConsumers = 1,
27945 .scale = 0.0f,
27946 .type = TestOperandType::FLOAT32,
27947 .zeroPoint = 0
27948 }, { // axis
27949 .channelQuant = {},
27950 .data = TestBuffer::createFromVector<int32_t>({-2}),
27951 .dimensions = {},
27952 .isIgnored = false,
27953 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
27954 .numberOfConsumers = 1,
27955 .scale = 0.0f,
27956 .type = TestOperandType::INT32,
27957 .zeroPoint = 0
27958 }, { // op2
27959 .channelQuant = {},
27960 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
27961 .dimensions = {2, 2, 5, 2},
27962 .isIgnored = false,
27963 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
27964 .numberOfConsumers = 0,
27965 .scale = 0.00390625f,
27966 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
27967 .zeroPoint = 0
27968 }},
27969 .operations = {{
27970 .inputs = {0, 1, 2},
27971 .outputs = {3},
27972 .type = TestOperationType::SOFTMAX
27973 }},
27974 .outputIndexes = {3}
27975 },
27976 .minSupportedVersion = TestHalVersion::V1_2,
27977 .referenced = {}
27978 };
27979 return model;
27980 }
27981
27982 const auto dummy_test_model_axis_quant8_dim4_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2_neg_2", get_test_model_axis_quant8_dim4_axis2_neg_2());
27983
27984 } // namespace generated_tests::softmax_v1_2
27985
27986 namespace generated_tests::softmax_v1_2 {
27987
get_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal_2()27988 const TestModel& get_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal_2() {
27989 static TestModel model = {
27990 .expectFailure = false,
27991 .expectedMultinomialDistributionTolerance = 0,
27992 .isRelaxed = false,
27993 .main = { // axis
27994 .inputIndexes = {4},
27995 .operands = {{ // op1
27996 .channelQuant = {},
27997 .data = TestBuffer::createFromVector<uint8_t>({}),
27998 .dimensions = {2, 2, 5, 2},
27999 .isIgnored = false,
28000 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
28001 .numberOfConsumers = 1,
28002 .scale = 0.25f,
28003 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28004 .zeroPoint = 128
28005 }, { // param3
28006 .channelQuant = {},
28007 .data = TestBuffer::createFromVector<float>({1e-06f}),
28008 .dimensions = {},
28009 .isIgnored = false,
28010 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28011 .numberOfConsumers = 1,
28012 .scale = 0.0f,
28013 .type = TestOperandType::FLOAT32,
28014 .zeroPoint = 0
28015 }, { // axis
28016 .channelQuant = {},
28017 .data = TestBuffer::createFromVector<int32_t>({-2}),
28018 .dimensions = {},
28019 .isIgnored = false,
28020 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28021 .numberOfConsumers = 1,
28022 .scale = 0.0f,
28023 .type = TestOperandType::INT32,
28024 .zeroPoint = 0
28025 }, { // op2
28026 .channelQuant = {},
28027 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28028 .dimensions = {2, 2, 5, 2},
28029 .isIgnored = false,
28030 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28031 .numberOfConsumers = 0,
28032 .scale = 0.00390625f,
28033 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28034 .zeroPoint = 0
28035 }, { // op1_new
28036 .channelQuant = {},
28037 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
28038 .dimensions = {2, 2, 5, 2},
28039 .isIgnored = false,
28040 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28041 .numberOfConsumers = 1,
28042 .scale = 0.25f,
28043 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28044 .zeroPoint = 128
28045 }, { // placeholder169
28046 .channelQuant = {},
28047 .data = TestBuffer::createFromVector<uint8_t>({128}),
28048 .dimensions = {1},
28049 .isIgnored = false,
28050 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28051 .numberOfConsumers = 1,
28052 .scale = 0.25f,
28053 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28054 .zeroPoint = 128
28055 }, { // param187
28056 .channelQuant = {},
28057 .data = TestBuffer::createFromVector<int32_t>({0}),
28058 .dimensions = {},
28059 .isIgnored = false,
28060 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28061 .numberOfConsumers = 1,
28062 .scale = 0.0f,
28063 .type = TestOperandType::INT32,
28064 .zeroPoint = 0
28065 }},
28066 .operations = {{
28067 .inputs = {4, 5, 6},
28068 .outputs = {0},
28069 .type = TestOperationType::ADD
28070 }, {
28071 .inputs = {0, 1, 2},
28072 .outputs = {3},
28073 .type = TestOperationType::SOFTMAX
28074 }},
28075 .outputIndexes = {3}
28076 },
28077 .minSupportedVersion = TestHalVersion::V1_2,
28078 .referenced = {}
28079 };
28080 return model;
28081 }
28082
28083 const auto dummy_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis2_neg_all_inputs_as_internal_2());
28084
28085 } // namespace generated_tests::softmax_v1_2
28086
28087 namespace generated_tests::softmax_v1_2 {
28088
get_test_model_axis_quant8_dim4_axis3_2()28089 const TestModel& get_test_model_axis_quant8_dim4_axis3_2() {
28090 static TestModel model = {
28091 .expectFailure = false,
28092 .expectedMultinomialDistributionTolerance = 0,
28093 .isRelaxed = false,
28094 .main = { // axis
28095 .inputIndexes = {0},
28096 .operands = {{ // op1
28097 .channelQuant = {},
28098 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
28099 .dimensions = {2, 2, 2, 5},
28100 .isIgnored = false,
28101 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28102 .numberOfConsumers = 1,
28103 .scale = 0.25f,
28104 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28105 .zeroPoint = 128
28106 }, { // param3
28107 .channelQuant = {},
28108 .data = TestBuffer::createFromVector<float>({1e-06f}),
28109 .dimensions = {},
28110 .isIgnored = false,
28111 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28112 .numberOfConsumers = 1,
28113 .scale = 0.0f,
28114 .type = TestOperandType::FLOAT32,
28115 .zeroPoint = 0
28116 }, { // axis
28117 .channelQuant = {},
28118 .data = TestBuffer::createFromVector<int32_t>({3}),
28119 .dimensions = {},
28120 .isIgnored = false,
28121 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28122 .numberOfConsumers = 1,
28123 .scale = 0.0f,
28124 .type = TestOperandType::INT32,
28125 .zeroPoint = 0
28126 }, { // op2
28127 .channelQuant = {},
28128 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28129 .dimensions = {2, 2, 2, 5},
28130 .isIgnored = false,
28131 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28132 .numberOfConsumers = 0,
28133 .scale = 0.00390625f,
28134 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28135 .zeroPoint = 0
28136 }},
28137 .operations = {{
28138 .inputs = {0, 1, 2},
28139 .outputs = {3},
28140 .type = TestOperationType::SOFTMAX
28141 }},
28142 .outputIndexes = {3}
28143 },
28144 .minSupportedVersion = TestHalVersion::V1_2,
28145 .referenced = {}
28146 };
28147 return model;
28148 }
28149
28150 const auto dummy_test_model_axis_quant8_dim4_axis3_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3_2", get_test_model_axis_quant8_dim4_axis3_2());
28151
28152 } // namespace generated_tests::softmax_v1_2
28153
28154 namespace generated_tests::softmax_v1_2 {
28155
get_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal_2()28156 const TestModel& get_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal_2() {
28157 static TestModel model = {
28158 .expectFailure = false,
28159 .expectedMultinomialDistributionTolerance = 0,
28160 .isRelaxed = false,
28161 .main = { // axis
28162 .inputIndexes = {4},
28163 .operands = {{ // op1
28164 .channelQuant = {},
28165 .data = TestBuffer::createFromVector<uint8_t>({}),
28166 .dimensions = {2, 2, 2, 5},
28167 .isIgnored = false,
28168 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
28169 .numberOfConsumers = 1,
28170 .scale = 0.25f,
28171 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28172 .zeroPoint = 128
28173 }, { // param3
28174 .channelQuant = {},
28175 .data = TestBuffer::createFromVector<float>({1e-06f}),
28176 .dimensions = {},
28177 .isIgnored = false,
28178 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28179 .numberOfConsumers = 1,
28180 .scale = 0.0f,
28181 .type = TestOperandType::FLOAT32,
28182 .zeroPoint = 0
28183 }, { // axis
28184 .channelQuant = {},
28185 .data = TestBuffer::createFromVector<int32_t>({3}),
28186 .dimensions = {},
28187 .isIgnored = false,
28188 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28189 .numberOfConsumers = 1,
28190 .scale = 0.0f,
28191 .type = TestOperandType::INT32,
28192 .zeroPoint = 0
28193 }, { // op2
28194 .channelQuant = {},
28195 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28196 .dimensions = {2, 2, 2, 5},
28197 .isIgnored = false,
28198 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28199 .numberOfConsumers = 0,
28200 .scale = 0.00390625f,
28201 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28202 .zeroPoint = 0
28203 }, { // op1_new
28204 .channelQuant = {},
28205 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
28206 .dimensions = {2, 2, 2, 5},
28207 .isIgnored = false,
28208 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28209 .numberOfConsumers = 1,
28210 .scale = 0.25f,
28211 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28212 .zeroPoint = 128
28213 }, { // placeholder170
28214 .channelQuant = {},
28215 .data = TestBuffer::createFromVector<uint8_t>({128}),
28216 .dimensions = {1},
28217 .isIgnored = false,
28218 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28219 .numberOfConsumers = 1,
28220 .scale = 0.25f,
28221 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28222 .zeroPoint = 128
28223 }, { // param188
28224 .channelQuant = {},
28225 .data = TestBuffer::createFromVector<int32_t>({0}),
28226 .dimensions = {},
28227 .isIgnored = false,
28228 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28229 .numberOfConsumers = 1,
28230 .scale = 0.0f,
28231 .type = TestOperandType::INT32,
28232 .zeroPoint = 0
28233 }},
28234 .operations = {{
28235 .inputs = {4, 5, 6},
28236 .outputs = {0},
28237 .type = TestOperationType::ADD
28238 }, {
28239 .inputs = {0, 1, 2},
28240 .outputs = {3},
28241 .type = TestOperationType::SOFTMAX
28242 }},
28243 .outputIndexes = {3}
28244 },
28245 .minSupportedVersion = TestHalVersion::V1_2,
28246 .referenced = {}
28247 };
28248 return model;
28249 }
28250
28251 const auto dummy_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis3_all_inputs_as_internal_2());
28252
28253 } // namespace generated_tests::softmax_v1_2
28254
28255 namespace generated_tests::softmax_v1_2 {
28256
get_test_model_axis_quant8_dim4_axis3_neg_2()28257 const TestModel& get_test_model_axis_quant8_dim4_axis3_neg_2() {
28258 static TestModel model = {
28259 .expectFailure = false,
28260 .expectedMultinomialDistributionTolerance = 0,
28261 .isRelaxed = false,
28262 .main = { // axis
28263 .inputIndexes = {0},
28264 .operands = {{ // op1
28265 .channelQuant = {},
28266 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
28267 .dimensions = {2, 2, 2, 5},
28268 .isIgnored = false,
28269 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28270 .numberOfConsumers = 1,
28271 .scale = 0.25f,
28272 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28273 .zeroPoint = 128
28274 }, { // param3
28275 .channelQuant = {},
28276 .data = TestBuffer::createFromVector<float>({1e-06f}),
28277 .dimensions = {},
28278 .isIgnored = false,
28279 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28280 .numberOfConsumers = 1,
28281 .scale = 0.0f,
28282 .type = TestOperandType::FLOAT32,
28283 .zeroPoint = 0
28284 }, { // axis
28285 .channelQuant = {},
28286 .data = TestBuffer::createFromVector<int32_t>({-1}),
28287 .dimensions = {},
28288 .isIgnored = false,
28289 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28290 .numberOfConsumers = 1,
28291 .scale = 0.0f,
28292 .type = TestOperandType::INT32,
28293 .zeroPoint = 0
28294 }, { // op2
28295 .channelQuant = {},
28296 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28297 .dimensions = {2, 2, 2, 5},
28298 .isIgnored = false,
28299 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28300 .numberOfConsumers = 0,
28301 .scale = 0.00390625f,
28302 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28303 .zeroPoint = 0
28304 }},
28305 .operations = {{
28306 .inputs = {0, 1, 2},
28307 .outputs = {3},
28308 .type = TestOperationType::SOFTMAX
28309 }},
28310 .outputIndexes = {3}
28311 },
28312 .minSupportedVersion = TestHalVersion::V1_0,
28313 .referenced = {}
28314 };
28315 return model;
28316 }
28317
28318 const auto dummy_test_model_axis_quant8_dim4_axis3_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3_neg_2", get_test_model_axis_quant8_dim4_axis3_neg_2());
28319
28320 } // namespace generated_tests::softmax_v1_2
28321
28322 namespace generated_tests::softmax_v1_2 {
28323
get_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal_2()28324 const TestModel& get_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal_2() {
28325 static TestModel model = {
28326 .expectFailure = false,
28327 .expectedMultinomialDistributionTolerance = 0,
28328 .isRelaxed = false,
28329 .main = { // axis
28330 .inputIndexes = {4},
28331 .operands = {{ // op1
28332 .channelQuant = {},
28333 .data = TestBuffer::createFromVector<uint8_t>({}),
28334 .dimensions = {2, 2, 2, 5},
28335 .isIgnored = false,
28336 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
28337 .numberOfConsumers = 1,
28338 .scale = 0.25f,
28339 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28340 .zeroPoint = 128
28341 }, { // param3
28342 .channelQuant = {},
28343 .data = TestBuffer::createFromVector<float>({1e-06f}),
28344 .dimensions = {},
28345 .isIgnored = false,
28346 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28347 .numberOfConsumers = 1,
28348 .scale = 0.0f,
28349 .type = TestOperandType::FLOAT32,
28350 .zeroPoint = 0
28351 }, { // axis
28352 .channelQuant = {},
28353 .data = TestBuffer::createFromVector<int32_t>({-1}),
28354 .dimensions = {},
28355 .isIgnored = false,
28356 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28357 .numberOfConsumers = 1,
28358 .scale = 0.0f,
28359 .type = TestOperandType::INT32,
28360 .zeroPoint = 0
28361 }, { // op2
28362 .channelQuant = {},
28363 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28364 .dimensions = {2, 2, 2, 5},
28365 .isIgnored = false,
28366 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28367 .numberOfConsumers = 0,
28368 .scale = 0.00390625f,
28369 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28370 .zeroPoint = 0
28371 }, { // op1_new
28372 .channelQuant = {},
28373 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
28374 .dimensions = {2, 2, 2, 5},
28375 .isIgnored = false,
28376 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28377 .numberOfConsumers = 1,
28378 .scale = 0.25f,
28379 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28380 .zeroPoint = 128
28381 }, { // placeholder171
28382 .channelQuant = {},
28383 .data = TestBuffer::createFromVector<uint8_t>({128}),
28384 .dimensions = {1},
28385 .isIgnored = false,
28386 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28387 .numberOfConsumers = 1,
28388 .scale = 0.25f,
28389 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28390 .zeroPoint = 128
28391 }, { // param189
28392 .channelQuant = {},
28393 .data = TestBuffer::createFromVector<int32_t>({0}),
28394 .dimensions = {},
28395 .isIgnored = false,
28396 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28397 .numberOfConsumers = 1,
28398 .scale = 0.0f,
28399 .type = TestOperandType::INT32,
28400 .zeroPoint = 0
28401 }},
28402 .operations = {{
28403 .inputs = {4, 5, 6},
28404 .outputs = {0},
28405 .type = TestOperationType::ADD
28406 }, {
28407 .inputs = {0, 1, 2},
28408 .outputs = {3},
28409 .type = TestOperationType::SOFTMAX
28410 }},
28411 .outputIndexes = {3}
28412 },
28413 .minSupportedVersion = TestHalVersion::V1_0,
28414 .referenced = {}
28415 };
28416 return model;
28417 }
28418
28419 const auto dummy_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim4_axis3_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim4_axis3_neg_all_inputs_as_internal_2());
28420
28421 } // namespace generated_tests::softmax_v1_2
28422
28423 namespace generated_tests::softmax_v1_2 {
28424
get_test_model_axis_quant8_dim3_axis0_2()28425 const TestModel& get_test_model_axis_quant8_dim3_axis0_2() {
28426 static TestModel model = {
28427 .expectFailure = false,
28428 .expectedMultinomialDistributionTolerance = 0,
28429 .isRelaxed = false,
28430 .main = { // axis
28431 .inputIndexes = {0},
28432 .operands = {{ // op1
28433 .channelQuant = {},
28434 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
28435 .dimensions = {5, 2, 2},
28436 .isIgnored = false,
28437 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28438 .numberOfConsumers = 1,
28439 .scale = 0.25f,
28440 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28441 .zeroPoint = 128
28442 }, { // param3
28443 .channelQuant = {},
28444 .data = TestBuffer::createFromVector<float>({1e-06f}),
28445 .dimensions = {},
28446 .isIgnored = false,
28447 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28448 .numberOfConsumers = 1,
28449 .scale = 0.0f,
28450 .type = TestOperandType::FLOAT32,
28451 .zeroPoint = 0
28452 }, { // axis
28453 .channelQuant = {},
28454 .data = TestBuffer::createFromVector<int32_t>({0}),
28455 .dimensions = {},
28456 .isIgnored = false,
28457 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28458 .numberOfConsumers = 1,
28459 .scale = 0.0f,
28460 .type = TestOperandType::INT32,
28461 .zeroPoint = 0
28462 }, { // op2
28463 .channelQuant = {},
28464 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28465 .dimensions = {5, 2, 2},
28466 .isIgnored = false,
28467 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28468 .numberOfConsumers = 0,
28469 .scale = 0.00390625f,
28470 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28471 .zeroPoint = 0
28472 }},
28473 .operations = {{
28474 .inputs = {0, 1, 2},
28475 .outputs = {3},
28476 .type = TestOperationType::SOFTMAX
28477 }},
28478 .outputIndexes = {3}
28479 },
28480 .minSupportedVersion = TestHalVersion::V1_2,
28481 .referenced = {}
28482 };
28483 return model;
28484 }
28485
28486 const auto dummy_test_model_axis_quant8_dim3_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0_2", get_test_model_axis_quant8_dim3_axis0_2());
28487
28488 } // namespace generated_tests::softmax_v1_2
28489
28490 namespace generated_tests::softmax_v1_2 {
28491
get_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal_2()28492 const TestModel& get_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal_2() {
28493 static TestModel model = {
28494 .expectFailure = false,
28495 .expectedMultinomialDistributionTolerance = 0,
28496 .isRelaxed = false,
28497 .main = { // axis
28498 .inputIndexes = {4},
28499 .operands = {{ // op1
28500 .channelQuant = {},
28501 .data = TestBuffer::createFromVector<uint8_t>({}),
28502 .dimensions = {5, 2, 2},
28503 .isIgnored = false,
28504 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
28505 .numberOfConsumers = 1,
28506 .scale = 0.25f,
28507 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28508 .zeroPoint = 128
28509 }, { // param3
28510 .channelQuant = {},
28511 .data = TestBuffer::createFromVector<float>({1e-06f}),
28512 .dimensions = {},
28513 .isIgnored = false,
28514 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28515 .numberOfConsumers = 1,
28516 .scale = 0.0f,
28517 .type = TestOperandType::FLOAT32,
28518 .zeroPoint = 0
28519 }, { // axis
28520 .channelQuant = {},
28521 .data = TestBuffer::createFromVector<int32_t>({0}),
28522 .dimensions = {},
28523 .isIgnored = false,
28524 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28525 .numberOfConsumers = 1,
28526 .scale = 0.0f,
28527 .type = TestOperandType::INT32,
28528 .zeroPoint = 0
28529 }, { // op2
28530 .channelQuant = {},
28531 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28532 .dimensions = {5, 2, 2},
28533 .isIgnored = false,
28534 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28535 .numberOfConsumers = 0,
28536 .scale = 0.00390625f,
28537 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28538 .zeroPoint = 0
28539 }, { // op1_new
28540 .channelQuant = {},
28541 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
28542 .dimensions = {5, 2, 2},
28543 .isIgnored = false,
28544 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28545 .numberOfConsumers = 1,
28546 .scale = 0.25f,
28547 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28548 .zeroPoint = 128
28549 }, { // placeholder172
28550 .channelQuant = {},
28551 .data = TestBuffer::createFromVector<uint8_t>({128}),
28552 .dimensions = {1},
28553 .isIgnored = false,
28554 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28555 .numberOfConsumers = 1,
28556 .scale = 0.25f,
28557 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28558 .zeroPoint = 128
28559 }, { // param190
28560 .channelQuant = {},
28561 .data = TestBuffer::createFromVector<int32_t>({0}),
28562 .dimensions = {},
28563 .isIgnored = false,
28564 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28565 .numberOfConsumers = 1,
28566 .scale = 0.0f,
28567 .type = TestOperandType::INT32,
28568 .zeroPoint = 0
28569 }},
28570 .operations = {{
28571 .inputs = {4, 5, 6},
28572 .outputs = {0},
28573 .type = TestOperationType::ADD
28574 }, {
28575 .inputs = {0, 1, 2},
28576 .outputs = {3},
28577 .type = TestOperationType::SOFTMAX
28578 }},
28579 .outputIndexes = {3}
28580 },
28581 .minSupportedVersion = TestHalVersion::V1_2,
28582 .referenced = {}
28583 };
28584 return model;
28585 }
28586
28587 const auto dummy_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0_all_inputs_as_internal_2", get_test_model_axis_quant8_dim3_axis0_all_inputs_as_internal_2());
28588
28589 } // namespace generated_tests::softmax_v1_2
28590
28591 namespace generated_tests::softmax_v1_2 {
28592
get_test_model_axis_quant8_dim3_axis0_neg_2()28593 const TestModel& get_test_model_axis_quant8_dim3_axis0_neg_2() {
28594 static TestModel model = {
28595 .expectFailure = false,
28596 .expectedMultinomialDistributionTolerance = 0,
28597 .isRelaxed = false,
28598 .main = { // axis
28599 .inputIndexes = {0},
28600 .operands = {{ // op1
28601 .channelQuant = {},
28602 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
28603 .dimensions = {5, 2, 2},
28604 .isIgnored = false,
28605 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28606 .numberOfConsumers = 1,
28607 .scale = 0.25f,
28608 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28609 .zeroPoint = 128
28610 }, { // param3
28611 .channelQuant = {},
28612 .data = TestBuffer::createFromVector<float>({1e-06f}),
28613 .dimensions = {},
28614 .isIgnored = false,
28615 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28616 .numberOfConsumers = 1,
28617 .scale = 0.0f,
28618 .type = TestOperandType::FLOAT32,
28619 .zeroPoint = 0
28620 }, { // axis
28621 .channelQuant = {},
28622 .data = TestBuffer::createFromVector<int32_t>({-3}),
28623 .dimensions = {},
28624 .isIgnored = false,
28625 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28626 .numberOfConsumers = 1,
28627 .scale = 0.0f,
28628 .type = TestOperandType::INT32,
28629 .zeroPoint = 0
28630 }, { // op2
28631 .channelQuant = {},
28632 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28633 .dimensions = {5, 2, 2},
28634 .isIgnored = false,
28635 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28636 .numberOfConsumers = 0,
28637 .scale = 0.00390625f,
28638 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28639 .zeroPoint = 0
28640 }},
28641 .operations = {{
28642 .inputs = {0, 1, 2},
28643 .outputs = {3},
28644 .type = TestOperationType::SOFTMAX
28645 }},
28646 .outputIndexes = {3}
28647 },
28648 .minSupportedVersion = TestHalVersion::V1_2,
28649 .referenced = {}
28650 };
28651 return model;
28652 }
28653
28654 const auto dummy_test_model_axis_quant8_dim3_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0_neg_2", get_test_model_axis_quant8_dim3_axis0_neg_2());
28655
28656 } // namespace generated_tests::softmax_v1_2
28657
28658 namespace generated_tests::softmax_v1_2 {
28659
get_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal_2()28660 const TestModel& get_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal_2() {
28661 static TestModel model = {
28662 .expectFailure = false,
28663 .expectedMultinomialDistributionTolerance = 0,
28664 .isRelaxed = false,
28665 .main = { // axis
28666 .inputIndexes = {4},
28667 .operands = {{ // op1
28668 .channelQuant = {},
28669 .data = TestBuffer::createFromVector<uint8_t>({}),
28670 .dimensions = {5, 2, 2},
28671 .isIgnored = false,
28672 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
28673 .numberOfConsumers = 1,
28674 .scale = 0.25f,
28675 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28676 .zeroPoint = 128
28677 }, { // param3
28678 .channelQuant = {},
28679 .data = TestBuffer::createFromVector<float>({1e-06f}),
28680 .dimensions = {},
28681 .isIgnored = false,
28682 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28683 .numberOfConsumers = 1,
28684 .scale = 0.0f,
28685 .type = TestOperandType::FLOAT32,
28686 .zeroPoint = 0
28687 }, { // axis
28688 .channelQuant = {},
28689 .data = TestBuffer::createFromVector<int32_t>({-3}),
28690 .dimensions = {},
28691 .isIgnored = false,
28692 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28693 .numberOfConsumers = 1,
28694 .scale = 0.0f,
28695 .type = TestOperandType::INT32,
28696 .zeroPoint = 0
28697 }, { // op2
28698 .channelQuant = {},
28699 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28700 .dimensions = {5, 2, 2},
28701 .isIgnored = false,
28702 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28703 .numberOfConsumers = 0,
28704 .scale = 0.00390625f,
28705 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28706 .zeroPoint = 0
28707 }, { // op1_new
28708 .channelQuant = {},
28709 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 132, 124, 136, 120, 136, 120, 140, 116, 140, 116, 144, 112, 144, 112, 148, 108, 148, 108}),
28710 .dimensions = {5, 2, 2},
28711 .isIgnored = false,
28712 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28713 .numberOfConsumers = 1,
28714 .scale = 0.25f,
28715 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28716 .zeroPoint = 128
28717 }, { // placeholder173
28718 .channelQuant = {},
28719 .data = TestBuffer::createFromVector<uint8_t>({128}),
28720 .dimensions = {1},
28721 .isIgnored = false,
28722 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28723 .numberOfConsumers = 1,
28724 .scale = 0.25f,
28725 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28726 .zeroPoint = 128
28727 }, { // param191
28728 .channelQuant = {},
28729 .data = TestBuffer::createFromVector<int32_t>({0}),
28730 .dimensions = {},
28731 .isIgnored = false,
28732 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28733 .numberOfConsumers = 1,
28734 .scale = 0.0f,
28735 .type = TestOperandType::INT32,
28736 .zeroPoint = 0
28737 }},
28738 .operations = {{
28739 .inputs = {4, 5, 6},
28740 .outputs = {0},
28741 .type = TestOperationType::ADD
28742 }, {
28743 .inputs = {0, 1, 2},
28744 .outputs = {3},
28745 .type = TestOperationType::SOFTMAX
28746 }},
28747 .outputIndexes = {3}
28748 },
28749 .minSupportedVersion = TestHalVersion::V1_2,
28750 .referenced = {}
28751 };
28752 return model;
28753 }
28754
28755 const auto dummy_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim3_axis0_neg_all_inputs_as_internal_2());
28756
28757 } // namespace generated_tests::softmax_v1_2
28758
28759 namespace generated_tests::softmax_v1_2 {
28760
get_test_model_axis_quant8_dim3_axis1_2()28761 const TestModel& get_test_model_axis_quant8_dim3_axis1_2() {
28762 static TestModel model = {
28763 .expectFailure = false,
28764 .expectedMultinomialDistributionTolerance = 0,
28765 .isRelaxed = false,
28766 .main = { // axis
28767 .inputIndexes = {0},
28768 .operands = {{ // op1
28769 .channelQuant = {},
28770 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
28771 .dimensions = {2, 5, 2},
28772 .isIgnored = false,
28773 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28774 .numberOfConsumers = 1,
28775 .scale = 0.25f,
28776 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28777 .zeroPoint = 128
28778 }, { // param3
28779 .channelQuant = {},
28780 .data = TestBuffer::createFromVector<float>({1e-06f}),
28781 .dimensions = {},
28782 .isIgnored = false,
28783 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28784 .numberOfConsumers = 1,
28785 .scale = 0.0f,
28786 .type = TestOperandType::FLOAT32,
28787 .zeroPoint = 0
28788 }, { // axis
28789 .channelQuant = {},
28790 .data = TestBuffer::createFromVector<int32_t>({1}),
28791 .dimensions = {},
28792 .isIgnored = false,
28793 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28794 .numberOfConsumers = 1,
28795 .scale = 0.0f,
28796 .type = TestOperandType::INT32,
28797 .zeroPoint = 0
28798 }, { // op2
28799 .channelQuant = {},
28800 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28801 .dimensions = {2, 5, 2},
28802 .isIgnored = false,
28803 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28804 .numberOfConsumers = 0,
28805 .scale = 0.00390625f,
28806 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28807 .zeroPoint = 0
28808 }},
28809 .operations = {{
28810 .inputs = {0, 1, 2},
28811 .outputs = {3},
28812 .type = TestOperationType::SOFTMAX
28813 }},
28814 .outputIndexes = {3}
28815 },
28816 .minSupportedVersion = TestHalVersion::V1_2,
28817 .referenced = {}
28818 };
28819 return model;
28820 }
28821
28822 const auto dummy_test_model_axis_quant8_dim3_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1_2", get_test_model_axis_quant8_dim3_axis1_2());
28823
28824 } // namespace generated_tests::softmax_v1_2
28825
28826 namespace generated_tests::softmax_v1_2 {
28827
get_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal_2()28828 const TestModel& get_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal_2() {
28829 static TestModel model = {
28830 .expectFailure = false,
28831 .expectedMultinomialDistributionTolerance = 0,
28832 .isRelaxed = false,
28833 .main = { // axis
28834 .inputIndexes = {4},
28835 .operands = {{ // op1
28836 .channelQuant = {},
28837 .data = TestBuffer::createFromVector<uint8_t>({}),
28838 .dimensions = {2, 5, 2},
28839 .isIgnored = false,
28840 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
28841 .numberOfConsumers = 1,
28842 .scale = 0.25f,
28843 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28844 .zeroPoint = 128
28845 }, { // param3
28846 .channelQuant = {},
28847 .data = TestBuffer::createFromVector<float>({1e-06f}),
28848 .dimensions = {},
28849 .isIgnored = false,
28850 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28851 .numberOfConsumers = 1,
28852 .scale = 0.0f,
28853 .type = TestOperandType::FLOAT32,
28854 .zeroPoint = 0
28855 }, { // axis
28856 .channelQuant = {},
28857 .data = TestBuffer::createFromVector<int32_t>({1}),
28858 .dimensions = {},
28859 .isIgnored = false,
28860 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28861 .numberOfConsumers = 1,
28862 .scale = 0.0f,
28863 .type = TestOperandType::INT32,
28864 .zeroPoint = 0
28865 }, { // op2
28866 .channelQuant = {},
28867 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28868 .dimensions = {2, 5, 2},
28869 .isIgnored = false,
28870 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28871 .numberOfConsumers = 0,
28872 .scale = 0.00390625f,
28873 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28874 .zeroPoint = 0
28875 }, { // op1_new
28876 .channelQuant = {},
28877 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
28878 .dimensions = {2, 5, 2},
28879 .isIgnored = false,
28880 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28881 .numberOfConsumers = 1,
28882 .scale = 0.25f,
28883 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28884 .zeroPoint = 128
28885 }, { // placeholder174
28886 .channelQuant = {},
28887 .data = TestBuffer::createFromVector<uint8_t>({128}),
28888 .dimensions = {1},
28889 .isIgnored = false,
28890 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28891 .numberOfConsumers = 1,
28892 .scale = 0.25f,
28893 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28894 .zeroPoint = 128
28895 }, { // param192
28896 .channelQuant = {},
28897 .data = TestBuffer::createFromVector<int32_t>({0}),
28898 .dimensions = {},
28899 .isIgnored = false,
28900 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28901 .numberOfConsumers = 1,
28902 .scale = 0.0f,
28903 .type = TestOperandType::INT32,
28904 .zeroPoint = 0
28905 }},
28906 .operations = {{
28907 .inputs = {4, 5, 6},
28908 .outputs = {0},
28909 .type = TestOperationType::ADD
28910 }, {
28911 .inputs = {0, 1, 2},
28912 .outputs = {3},
28913 .type = TestOperationType::SOFTMAX
28914 }},
28915 .outputIndexes = {3}
28916 },
28917 .minSupportedVersion = TestHalVersion::V1_2,
28918 .referenced = {}
28919 };
28920 return model;
28921 }
28922
28923 const auto dummy_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1_all_inputs_as_internal_2", get_test_model_axis_quant8_dim3_axis1_all_inputs_as_internal_2());
28924
28925 } // namespace generated_tests::softmax_v1_2
28926
28927 namespace generated_tests::softmax_v1_2 {
28928
get_test_model_axis_quant8_dim3_axis1_neg_2()28929 const TestModel& get_test_model_axis_quant8_dim3_axis1_neg_2() {
28930 static TestModel model = {
28931 .expectFailure = false,
28932 .expectedMultinomialDistributionTolerance = 0,
28933 .isRelaxed = false,
28934 .main = { // axis
28935 .inputIndexes = {0},
28936 .operands = {{ // op1
28937 .channelQuant = {},
28938 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
28939 .dimensions = {2, 5, 2},
28940 .isIgnored = false,
28941 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
28942 .numberOfConsumers = 1,
28943 .scale = 0.25f,
28944 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28945 .zeroPoint = 128
28946 }, { // param3
28947 .channelQuant = {},
28948 .data = TestBuffer::createFromVector<float>({1e-06f}),
28949 .dimensions = {},
28950 .isIgnored = false,
28951 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28952 .numberOfConsumers = 1,
28953 .scale = 0.0f,
28954 .type = TestOperandType::FLOAT32,
28955 .zeroPoint = 0
28956 }, { // axis
28957 .channelQuant = {},
28958 .data = TestBuffer::createFromVector<int32_t>({-2}),
28959 .dimensions = {},
28960 .isIgnored = false,
28961 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
28962 .numberOfConsumers = 1,
28963 .scale = 0.0f,
28964 .type = TestOperandType::INT32,
28965 .zeroPoint = 0
28966 }, { // op2
28967 .channelQuant = {},
28968 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
28969 .dimensions = {2, 5, 2},
28970 .isIgnored = false,
28971 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
28972 .numberOfConsumers = 0,
28973 .scale = 0.00390625f,
28974 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
28975 .zeroPoint = 0
28976 }},
28977 .operations = {{
28978 .inputs = {0, 1, 2},
28979 .outputs = {3},
28980 .type = TestOperationType::SOFTMAX
28981 }},
28982 .outputIndexes = {3}
28983 },
28984 .minSupportedVersion = TestHalVersion::V1_2,
28985 .referenced = {}
28986 };
28987 return model;
28988 }
28989
28990 const auto dummy_test_model_axis_quant8_dim3_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1_neg_2", get_test_model_axis_quant8_dim3_axis1_neg_2());
28991
28992 } // namespace generated_tests::softmax_v1_2
28993
28994 namespace generated_tests::softmax_v1_2 {
28995
get_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal_2()28996 const TestModel& get_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal_2() {
28997 static TestModel model = {
28998 .expectFailure = false,
28999 .expectedMultinomialDistributionTolerance = 0,
29000 .isRelaxed = false,
29001 .main = { // axis
29002 .inputIndexes = {4},
29003 .operands = {{ // op1
29004 .channelQuant = {},
29005 .data = TestBuffer::createFromVector<uint8_t>({}),
29006 .dimensions = {2, 5, 2},
29007 .isIgnored = false,
29008 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
29009 .numberOfConsumers = 1,
29010 .scale = 0.25f,
29011 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29012 .zeroPoint = 128
29013 }, { // param3
29014 .channelQuant = {},
29015 .data = TestBuffer::createFromVector<float>({1e-06f}),
29016 .dimensions = {},
29017 .isIgnored = false,
29018 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29019 .numberOfConsumers = 1,
29020 .scale = 0.0f,
29021 .type = TestOperandType::FLOAT32,
29022 .zeroPoint = 0
29023 }, { // axis
29024 .channelQuant = {},
29025 .data = TestBuffer::createFromVector<int32_t>({-2}),
29026 .dimensions = {},
29027 .isIgnored = false,
29028 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29029 .numberOfConsumers = 1,
29030 .scale = 0.0f,
29031 .type = TestOperandType::INT32,
29032 .zeroPoint = 0
29033 }, { // op2
29034 .channelQuant = {},
29035 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29036 .dimensions = {2, 5, 2},
29037 .isIgnored = false,
29038 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29039 .numberOfConsumers = 0,
29040 .scale = 0.00390625f,
29041 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29042 .zeroPoint = 0
29043 }, { // op1_new
29044 .channelQuant = {},
29045 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108, 132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
29046 .dimensions = {2, 5, 2},
29047 .isIgnored = false,
29048 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29049 .numberOfConsumers = 1,
29050 .scale = 0.25f,
29051 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29052 .zeroPoint = 128
29053 }, { // placeholder175
29054 .channelQuant = {},
29055 .data = TestBuffer::createFromVector<uint8_t>({128}),
29056 .dimensions = {1},
29057 .isIgnored = false,
29058 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29059 .numberOfConsumers = 1,
29060 .scale = 0.25f,
29061 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29062 .zeroPoint = 128
29063 }, { // param193
29064 .channelQuant = {},
29065 .data = TestBuffer::createFromVector<int32_t>({0}),
29066 .dimensions = {},
29067 .isIgnored = false,
29068 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29069 .numberOfConsumers = 1,
29070 .scale = 0.0f,
29071 .type = TestOperandType::INT32,
29072 .zeroPoint = 0
29073 }},
29074 .operations = {{
29075 .inputs = {4, 5, 6},
29076 .outputs = {0},
29077 .type = TestOperationType::ADD
29078 }, {
29079 .inputs = {0, 1, 2},
29080 .outputs = {3},
29081 .type = TestOperationType::SOFTMAX
29082 }},
29083 .outputIndexes = {3}
29084 },
29085 .minSupportedVersion = TestHalVersion::V1_2,
29086 .referenced = {}
29087 };
29088 return model;
29089 }
29090
29091 const auto dummy_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim3_axis1_neg_all_inputs_as_internal_2());
29092
29093 } // namespace generated_tests::softmax_v1_2
29094
29095 namespace generated_tests::softmax_v1_2 {
29096
get_test_model_axis_quant8_dim3_axis2_2()29097 const TestModel& get_test_model_axis_quant8_dim3_axis2_2() {
29098 static TestModel model = {
29099 .expectFailure = false,
29100 .expectedMultinomialDistributionTolerance = 0,
29101 .isRelaxed = false,
29102 .main = { // axis
29103 .inputIndexes = {0},
29104 .operands = {{ // op1
29105 .channelQuant = {},
29106 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
29107 .dimensions = {2, 2, 5},
29108 .isIgnored = false,
29109 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29110 .numberOfConsumers = 1,
29111 .scale = 0.25f,
29112 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29113 .zeroPoint = 128
29114 }, { // param3
29115 .channelQuant = {},
29116 .data = TestBuffer::createFromVector<float>({1e-06f}),
29117 .dimensions = {},
29118 .isIgnored = false,
29119 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29120 .numberOfConsumers = 1,
29121 .scale = 0.0f,
29122 .type = TestOperandType::FLOAT32,
29123 .zeroPoint = 0
29124 }, { // axis
29125 .channelQuant = {},
29126 .data = TestBuffer::createFromVector<int32_t>({2}),
29127 .dimensions = {},
29128 .isIgnored = false,
29129 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29130 .numberOfConsumers = 1,
29131 .scale = 0.0f,
29132 .type = TestOperandType::INT32,
29133 .zeroPoint = 0
29134 }, { // op2
29135 .channelQuant = {},
29136 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29137 .dimensions = {2, 2, 5},
29138 .isIgnored = false,
29139 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29140 .numberOfConsumers = 0,
29141 .scale = 0.00390625f,
29142 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29143 .zeroPoint = 0
29144 }},
29145 .operations = {{
29146 .inputs = {0, 1, 2},
29147 .outputs = {3},
29148 .type = TestOperationType::SOFTMAX
29149 }},
29150 .outputIndexes = {3}
29151 },
29152 .minSupportedVersion = TestHalVersion::V1_2,
29153 .referenced = {}
29154 };
29155 return model;
29156 }
29157
29158 const auto dummy_test_model_axis_quant8_dim3_axis2_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2_2", get_test_model_axis_quant8_dim3_axis2_2());
29159
29160 } // namespace generated_tests::softmax_v1_2
29161
29162 namespace generated_tests::softmax_v1_2 {
29163
get_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal_2()29164 const TestModel& get_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal_2() {
29165 static TestModel model = {
29166 .expectFailure = false,
29167 .expectedMultinomialDistributionTolerance = 0,
29168 .isRelaxed = false,
29169 .main = { // axis
29170 .inputIndexes = {4},
29171 .operands = {{ // op1
29172 .channelQuant = {},
29173 .data = TestBuffer::createFromVector<uint8_t>({}),
29174 .dimensions = {2, 2, 5},
29175 .isIgnored = false,
29176 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
29177 .numberOfConsumers = 1,
29178 .scale = 0.25f,
29179 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29180 .zeroPoint = 128
29181 }, { // param3
29182 .channelQuant = {},
29183 .data = TestBuffer::createFromVector<float>({1e-06f}),
29184 .dimensions = {},
29185 .isIgnored = false,
29186 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29187 .numberOfConsumers = 1,
29188 .scale = 0.0f,
29189 .type = TestOperandType::FLOAT32,
29190 .zeroPoint = 0
29191 }, { // axis
29192 .channelQuant = {},
29193 .data = TestBuffer::createFromVector<int32_t>({2}),
29194 .dimensions = {},
29195 .isIgnored = false,
29196 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29197 .numberOfConsumers = 1,
29198 .scale = 0.0f,
29199 .type = TestOperandType::INT32,
29200 .zeroPoint = 0
29201 }, { // op2
29202 .channelQuant = {},
29203 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29204 .dimensions = {2, 2, 5},
29205 .isIgnored = false,
29206 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29207 .numberOfConsumers = 0,
29208 .scale = 0.00390625f,
29209 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29210 .zeroPoint = 0
29211 }, { // op1_new
29212 .channelQuant = {},
29213 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
29214 .dimensions = {2, 2, 5},
29215 .isIgnored = false,
29216 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29217 .numberOfConsumers = 1,
29218 .scale = 0.25f,
29219 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29220 .zeroPoint = 128
29221 }, { // placeholder176
29222 .channelQuant = {},
29223 .data = TestBuffer::createFromVector<uint8_t>({128}),
29224 .dimensions = {1},
29225 .isIgnored = false,
29226 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29227 .numberOfConsumers = 1,
29228 .scale = 0.25f,
29229 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29230 .zeroPoint = 128
29231 }, { // param194
29232 .channelQuant = {},
29233 .data = TestBuffer::createFromVector<int32_t>({0}),
29234 .dimensions = {},
29235 .isIgnored = false,
29236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29237 .numberOfConsumers = 1,
29238 .scale = 0.0f,
29239 .type = TestOperandType::INT32,
29240 .zeroPoint = 0
29241 }},
29242 .operations = {{
29243 .inputs = {4, 5, 6},
29244 .outputs = {0},
29245 .type = TestOperationType::ADD
29246 }, {
29247 .inputs = {0, 1, 2},
29248 .outputs = {3},
29249 .type = TestOperationType::SOFTMAX
29250 }},
29251 .outputIndexes = {3}
29252 },
29253 .minSupportedVersion = TestHalVersion::V1_2,
29254 .referenced = {}
29255 };
29256 return model;
29257 }
29258
29259 const auto dummy_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2_all_inputs_as_internal_2", get_test_model_axis_quant8_dim3_axis2_all_inputs_as_internal_2());
29260
29261 } // namespace generated_tests::softmax_v1_2
29262
29263 namespace generated_tests::softmax_v1_2 {
29264
get_test_model_axis_quant8_dim3_axis2_neg_2()29265 const TestModel& get_test_model_axis_quant8_dim3_axis2_neg_2() {
29266 static TestModel model = {
29267 .expectFailure = false,
29268 .expectedMultinomialDistributionTolerance = 0,
29269 .isRelaxed = false,
29270 .main = { // axis
29271 .inputIndexes = {0},
29272 .operands = {{ // op1
29273 .channelQuant = {},
29274 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
29275 .dimensions = {2, 2, 5},
29276 .isIgnored = false,
29277 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29278 .numberOfConsumers = 1,
29279 .scale = 0.25f,
29280 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29281 .zeroPoint = 128
29282 }, { // param3
29283 .channelQuant = {},
29284 .data = TestBuffer::createFromVector<float>({1e-06f}),
29285 .dimensions = {},
29286 .isIgnored = false,
29287 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29288 .numberOfConsumers = 1,
29289 .scale = 0.0f,
29290 .type = TestOperandType::FLOAT32,
29291 .zeroPoint = 0
29292 }, { // axis
29293 .channelQuant = {},
29294 .data = TestBuffer::createFromVector<int32_t>({-1}),
29295 .dimensions = {},
29296 .isIgnored = false,
29297 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29298 .numberOfConsumers = 1,
29299 .scale = 0.0f,
29300 .type = TestOperandType::INT32,
29301 .zeroPoint = 0
29302 }, { // op2
29303 .channelQuant = {},
29304 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29305 .dimensions = {2, 2, 5},
29306 .isIgnored = false,
29307 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29308 .numberOfConsumers = 0,
29309 .scale = 0.00390625f,
29310 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29311 .zeroPoint = 0
29312 }},
29313 .operations = {{
29314 .inputs = {0, 1, 2},
29315 .outputs = {3},
29316 .type = TestOperationType::SOFTMAX
29317 }},
29318 .outputIndexes = {3}
29319 },
29320 .minSupportedVersion = TestHalVersion::V1_2,
29321 .referenced = {}
29322 };
29323 return model;
29324 }
29325
29326 const auto dummy_test_model_axis_quant8_dim3_axis2_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2_neg_2", get_test_model_axis_quant8_dim3_axis2_neg_2());
29327
29328 } // namespace generated_tests::softmax_v1_2
29329
29330 namespace generated_tests::softmax_v1_2 {
29331
get_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal_2()29332 const TestModel& get_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal_2() {
29333 static TestModel model = {
29334 .expectFailure = false,
29335 .expectedMultinomialDistributionTolerance = 0,
29336 .isRelaxed = false,
29337 .main = { // axis
29338 .inputIndexes = {4},
29339 .operands = {{ // op1
29340 .channelQuant = {},
29341 .data = TestBuffer::createFromVector<uint8_t>({}),
29342 .dimensions = {2, 2, 5},
29343 .isIgnored = false,
29344 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
29345 .numberOfConsumers = 1,
29346 .scale = 0.25f,
29347 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29348 .zeroPoint = 128
29349 }, { // param3
29350 .channelQuant = {},
29351 .data = TestBuffer::createFromVector<float>({1e-06f}),
29352 .dimensions = {},
29353 .isIgnored = false,
29354 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29355 .numberOfConsumers = 1,
29356 .scale = 0.0f,
29357 .type = TestOperandType::FLOAT32,
29358 .zeroPoint = 0
29359 }, { // axis
29360 .channelQuant = {},
29361 .data = TestBuffer::createFromVector<int32_t>({-1}),
29362 .dimensions = {},
29363 .isIgnored = false,
29364 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29365 .numberOfConsumers = 1,
29366 .scale = 0.0f,
29367 .type = TestOperandType::INT32,
29368 .zeroPoint = 0
29369 }, { // op2
29370 .channelQuant = {},
29371 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29372 .dimensions = {2, 2, 5},
29373 .isIgnored = false,
29374 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29375 .numberOfConsumers = 0,
29376 .scale = 0.00390625f,
29377 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29378 .zeroPoint = 0
29379 }, { // op1_new
29380 .channelQuant = {},
29381 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108, 132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
29382 .dimensions = {2, 2, 5},
29383 .isIgnored = false,
29384 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29385 .numberOfConsumers = 1,
29386 .scale = 0.25f,
29387 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29388 .zeroPoint = 128
29389 }, { // placeholder177
29390 .channelQuant = {},
29391 .data = TestBuffer::createFromVector<uint8_t>({128}),
29392 .dimensions = {1},
29393 .isIgnored = false,
29394 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29395 .numberOfConsumers = 1,
29396 .scale = 0.25f,
29397 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29398 .zeroPoint = 128
29399 }, { // param195
29400 .channelQuant = {},
29401 .data = TestBuffer::createFromVector<int32_t>({0}),
29402 .dimensions = {},
29403 .isIgnored = false,
29404 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29405 .numberOfConsumers = 1,
29406 .scale = 0.0f,
29407 .type = TestOperandType::INT32,
29408 .zeroPoint = 0
29409 }},
29410 .operations = {{
29411 .inputs = {4, 5, 6},
29412 .outputs = {0},
29413 .type = TestOperationType::ADD
29414 }, {
29415 .inputs = {0, 1, 2},
29416 .outputs = {3},
29417 .type = TestOperationType::SOFTMAX
29418 }},
29419 .outputIndexes = {3}
29420 },
29421 .minSupportedVersion = TestHalVersion::V1_2,
29422 .referenced = {}
29423 };
29424 return model;
29425 }
29426
29427 const auto dummy_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim3_axis2_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim3_axis2_neg_all_inputs_as_internal_2());
29428
29429 } // namespace generated_tests::softmax_v1_2
29430
29431 namespace generated_tests::softmax_v1_2 {
29432
get_test_model_axis_quant8_dim2_axis0_2()29433 const TestModel& get_test_model_axis_quant8_dim2_axis0_2() {
29434 static TestModel model = {
29435 .expectFailure = false,
29436 .expectedMultinomialDistributionTolerance = 0,
29437 .isRelaxed = false,
29438 .main = { // axis
29439 .inputIndexes = {0},
29440 .operands = {{ // op1
29441 .channelQuant = {},
29442 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
29443 .dimensions = {5, 2},
29444 .isIgnored = false,
29445 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29446 .numberOfConsumers = 1,
29447 .scale = 0.25f,
29448 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29449 .zeroPoint = 128
29450 }, { // param3
29451 .channelQuant = {},
29452 .data = TestBuffer::createFromVector<float>({1e-06f}),
29453 .dimensions = {},
29454 .isIgnored = false,
29455 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29456 .numberOfConsumers = 1,
29457 .scale = 0.0f,
29458 .type = TestOperandType::FLOAT32,
29459 .zeroPoint = 0
29460 }, { // axis
29461 .channelQuant = {},
29462 .data = TestBuffer::createFromVector<int32_t>({0}),
29463 .dimensions = {},
29464 .isIgnored = false,
29465 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29466 .numberOfConsumers = 1,
29467 .scale = 0.0f,
29468 .type = TestOperandType::INT32,
29469 .zeroPoint = 0
29470 }, { // op2
29471 .channelQuant = {},
29472 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29473 .dimensions = {5, 2},
29474 .isIgnored = false,
29475 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29476 .numberOfConsumers = 0,
29477 .scale = 0.00390625f,
29478 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29479 .zeroPoint = 0
29480 }},
29481 .operations = {{
29482 .inputs = {0, 1, 2},
29483 .outputs = {3},
29484 .type = TestOperationType::SOFTMAX
29485 }},
29486 .outputIndexes = {3}
29487 },
29488 .minSupportedVersion = TestHalVersion::V1_2,
29489 .referenced = {}
29490 };
29491 return model;
29492 }
29493
29494 const auto dummy_test_model_axis_quant8_dim2_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0_2", get_test_model_axis_quant8_dim2_axis0_2());
29495
29496 } // namespace generated_tests::softmax_v1_2
29497
29498 namespace generated_tests::softmax_v1_2 {
29499
get_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal_2()29500 const TestModel& get_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal_2() {
29501 static TestModel model = {
29502 .expectFailure = false,
29503 .expectedMultinomialDistributionTolerance = 0,
29504 .isRelaxed = false,
29505 .main = { // axis
29506 .inputIndexes = {4},
29507 .operands = {{ // op1
29508 .channelQuant = {},
29509 .data = TestBuffer::createFromVector<uint8_t>({}),
29510 .dimensions = {5, 2},
29511 .isIgnored = false,
29512 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
29513 .numberOfConsumers = 1,
29514 .scale = 0.25f,
29515 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29516 .zeroPoint = 128
29517 }, { // param3
29518 .channelQuant = {},
29519 .data = TestBuffer::createFromVector<float>({1e-06f}),
29520 .dimensions = {},
29521 .isIgnored = false,
29522 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29523 .numberOfConsumers = 1,
29524 .scale = 0.0f,
29525 .type = TestOperandType::FLOAT32,
29526 .zeroPoint = 0
29527 }, { // axis
29528 .channelQuant = {},
29529 .data = TestBuffer::createFromVector<int32_t>({0}),
29530 .dimensions = {},
29531 .isIgnored = false,
29532 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29533 .numberOfConsumers = 1,
29534 .scale = 0.0f,
29535 .type = TestOperandType::INT32,
29536 .zeroPoint = 0
29537 }, { // op2
29538 .channelQuant = {},
29539 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29540 .dimensions = {5, 2},
29541 .isIgnored = false,
29542 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29543 .numberOfConsumers = 0,
29544 .scale = 0.00390625f,
29545 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29546 .zeroPoint = 0
29547 }, { // op1_new
29548 .channelQuant = {},
29549 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
29550 .dimensions = {5, 2},
29551 .isIgnored = false,
29552 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29553 .numberOfConsumers = 1,
29554 .scale = 0.25f,
29555 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29556 .zeroPoint = 128
29557 }, { // placeholder178
29558 .channelQuant = {},
29559 .data = TestBuffer::createFromVector<uint8_t>({128}),
29560 .dimensions = {1},
29561 .isIgnored = false,
29562 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29563 .numberOfConsumers = 1,
29564 .scale = 0.25f,
29565 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29566 .zeroPoint = 128
29567 }, { // param196
29568 .channelQuant = {},
29569 .data = TestBuffer::createFromVector<int32_t>({0}),
29570 .dimensions = {},
29571 .isIgnored = false,
29572 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29573 .numberOfConsumers = 1,
29574 .scale = 0.0f,
29575 .type = TestOperandType::INT32,
29576 .zeroPoint = 0
29577 }},
29578 .operations = {{
29579 .inputs = {4, 5, 6},
29580 .outputs = {0},
29581 .type = TestOperationType::ADD
29582 }, {
29583 .inputs = {0, 1, 2},
29584 .outputs = {3},
29585 .type = TestOperationType::SOFTMAX
29586 }},
29587 .outputIndexes = {3}
29588 },
29589 .minSupportedVersion = TestHalVersion::V1_2,
29590 .referenced = {}
29591 };
29592 return model;
29593 }
29594
29595 const auto dummy_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0_all_inputs_as_internal_2", get_test_model_axis_quant8_dim2_axis0_all_inputs_as_internal_2());
29596
29597 } // namespace generated_tests::softmax_v1_2
29598
29599 namespace generated_tests::softmax_v1_2 {
29600
get_test_model_axis_quant8_dim2_axis0_neg_2()29601 const TestModel& get_test_model_axis_quant8_dim2_axis0_neg_2() {
29602 static TestModel model = {
29603 .expectFailure = false,
29604 .expectedMultinomialDistributionTolerance = 0,
29605 .isRelaxed = false,
29606 .main = { // axis
29607 .inputIndexes = {0},
29608 .operands = {{ // op1
29609 .channelQuant = {},
29610 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
29611 .dimensions = {5, 2},
29612 .isIgnored = false,
29613 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29614 .numberOfConsumers = 1,
29615 .scale = 0.25f,
29616 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29617 .zeroPoint = 128
29618 }, { // param3
29619 .channelQuant = {},
29620 .data = TestBuffer::createFromVector<float>({1e-06f}),
29621 .dimensions = {},
29622 .isIgnored = false,
29623 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29624 .numberOfConsumers = 1,
29625 .scale = 0.0f,
29626 .type = TestOperandType::FLOAT32,
29627 .zeroPoint = 0
29628 }, { // axis
29629 .channelQuant = {},
29630 .data = TestBuffer::createFromVector<int32_t>({-2}),
29631 .dimensions = {},
29632 .isIgnored = false,
29633 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29634 .numberOfConsumers = 1,
29635 .scale = 0.0f,
29636 .type = TestOperandType::INT32,
29637 .zeroPoint = 0
29638 }, { // op2
29639 .channelQuant = {},
29640 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29641 .dimensions = {5, 2},
29642 .isIgnored = false,
29643 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29644 .numberOfConsumers = 0,
29645 .scale = 0.00390625f,
29646 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29647 .zeroPoint = 0
29648 }},
29649 .operations = {{
29650 .inputs = {0, 1, 2},
29651 .outputs = {3},
29652 .type = TestOperationType::SOFTMAX
29653 }},
29654 .outputIndexes = {3}
29655 },
29656 .minSupportedVersion = TestHalVersion::V1_2,
29657 .referenced = {}
29658 };
29659 return model;
29660 }
29661
29662 const auto dummy_test_model_axis_quant8_dim2_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0_neg_2", get_test_model_axis_quant8_dim2_axis0_neg_2());
29663
29664 } // namespace generated_tests::softmax_v1_2
29665
29666 namespace generated_tests::softmax_v1_2 {
29667
get_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal_2()29668 const TestModel& get_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal_2() {
29669 static TestModel model = {
29670 .expectFailure = false,
29671 .expectedMultinomialDistributionTolerance = 0,
29672 .isRelaxed = false,
29673 .main = { // axis
29674 .inputIndexes = {4},
29675 .operands = {{ // op1
29676 .channelQuant = {},
29677 .data = TestBuffer::createFromVector<uint8_t>({}),
29678 .dimensions = {5, 2},
29679 .isIgnored = false,
29680 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
29681 .numberOfConsumers = 1,
29682 .scale = 0.25f,
29683 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29684 .zeroPoint = 128
29685 }, { // param3
29686 .channelQuant = {},
29687 .data = TestBuffer::createFromVector<float>({1e-06f}),
29688 .dimensions = {},
29689 .isIgnored = false,
29690 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29691 .numberOfConsumers = 1,
29692 .scale = 0.0f,
29693 .type = TestOperandType::FLOAT32,
29694 .zeroPoint = 0
29695 }, { // axis
29696 .channelQuant = {},
29697 .data = TestBuffer::createFromVector<int32_t>({-2}),
29698 .dimensions = {},
29699 .isIgnored = false,
29700 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29701 .numberOfConsumers = 1,
29702 .scale = 0.0f,
29703 .type = TestOperandType::INT32,
29704 .zeroPoint = 0
29705 }, { // op2
29706 .channelQuant = {},
29707 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29708 .dimensions = {5, 2},
29709 .isIgnored = false,
29710 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29711 .numberOfConsumers = 0,
29712 .scale = 0.00390625f,
29713 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29714 .zeroPoint = 0
29715 }, { // op1_new
29716 .channelQuant = {},
29717 .data = TestBuffer::createFromVector<uint8_t>({132, 124, 136, 120, 140, 116, 144, 112, 148, 108}),
29718 .dimensions = {5, 2},
29719 .isIgnored = false,
29720 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29721 .numberOfConsumers = 1,
29722 .scale = 0.25f,
29723 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29724 .zeroPoint = 128
29725 }, { // placeholder179
29726 .channelQuant = {},
29727 .data = TestBuffer::createFromVector<uint8_t>({128}),
29728 .dimensions = {1},
29729 .isIgnored = false,
29730 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29731 .numberOfConsumers = 1,
29732 .scale = 0.25f,
29733 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29734 .zeroPoint = 128
29735 }, { // param197
29736 .channelQuant = {},
29737 .data = TestBuffer::createFromVector<int32_t>({0}),
29738 .dimensions = {},
29739 .isIgnored = false,
29740 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29741 .numberOfConsumers = 1,
29742 .scale = 0.0f,
29743 .type = TestOperandType::INT32,
29744 .zeroPoint = 0
29745 }},
29746 .operations = {{
29747 .inputs = {4, 5, 6},
29748 .outputs = {0},
29749 .type = TestOperationType::ADD
29750 }, {
29751 .inputs = {0, 1, 2},
29752 .outputs = {3},
29753 .type = TestOperationType::SOFTMAX
29754 }},
29755 .outputIndexes = {3}
29756 },
29757 .minSupportedVersion = TestHalVersion::V1_2,
29758 .referenced = {}
29759 };
29760 return model;
29761 }
29762
29763 const auto dummy_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim2_axis0_neg_all_inputs_as_internal_2());
29764
29765 } // namespace generated_tests::softmax_v1_2
29766
29767 namespace generated_tests::softmax_v1_2 {
29768
get_test_model_axis_quant8_dim2_axis1_2()29769 const TestModel& get_test_model_axis_quant8_dim2_axis1_2() {
29770 static TestModel model = {
29771 .expectFailure = false,
29772 .expectedMultinomialDistributionTolerance = 0,
29773 .isRelaxed = false,
29774 .main = { // axis
29775 .inputIndexes = {0},
29776 .operands = {{ // op1
29777 .channelQuant = {},
29778 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
29779 .dimensions = {2, 5},
29780 .isIgnored = false,
29781 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29782 .numberOfConsumers = 1,
29783 .scale = 0.25f,
29784 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29785 .zeroPoint = 128
29786 }, { // param3
29787 .channelQuant = {},
29788 .data = TestBuffer::createFromVector<float>({1e-06f}),
29789 .dimensions = {},
29790 .isIgnored = false,
29791 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29792 .numberOfConsumers = 1,
29793 .scale = 0.0f,
29794 .type = TestOperandType::FLOAT32,
29795 .zeroPoint = 0
29796 }, { // axis
29797 .channelQuant = {},
29798 .data = TestBuffer::createFromVector<int32_t>({1}),
29799 .dimensions = {},
29800 .isIgnored = false,
29801 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29802 .numberOfConsumers = 1,
29803 .scale = 0.0f,
29804 .type = TestOperandType::INT32,
29805 .zeroPoint = 0
29806 }, { // op2
29807 .channelQuant = {},
29808 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29809 .dimensions = {2, 5},
29810 .isIgnored = false,
29811 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29812 .numberOfConsumers = 0,
29813 .scale = 0.00390625f,
29814 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29815 .zeroPoint = 0
29816 }},
29817 .operations = {{
29818 .inputs = {0, 1, 2},
29819 .outputs = {3},
29820 .type = TestOperationType::SOFTMAX
29821 }},
29822 .outputIndexes = {3}
29823 },
29824 .minSupportedVersion = TestHalVersion::V1_2,
29825 .referenced = {}
29826 };
29827 return model;
29828 }
29829
29830 const auto dummy_test_model_axis_quant8_dim2_axis1_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1_2", get_test_model_axis_quant8_dim2_axis1_2());
29831
29832 } // namespace generated_tests::softmax_v1_2
29833
29834 namespace generated_tests::softmax_v1_2 {
29835
get_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal_2()29836 const TestModel& get_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal_2() {
29837 static TestModel model = {
29838 .expectFailure = false,
29839 .expectedMultinomialDistributionTolerance = 0,
29840 .isRelaxed = false,
29841 .main = { // axis
29842 .inputIndexes = {4},
29843 .operands = {{ // op1
29844 .channelQuant = {},
29845 .data = TestBuffer::createFromVector<uint8_t>({}),
29846 .dimensions = {2, 5},
29847 .isIgnored = false,
29848 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
29849 .numberOfConsumers = 1,
29850 .scale = 0.25f,
29851 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29852 .zeroPoint = 128
29853 }, { // param3
29854 .channelQuant = {},
29855 .data = TestBuffer::createFromVector<float>({1e-06f}),
29856 .dimensions = {},
29857 .isIgnored = false,
29858 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29859 .numberOfConsumers = 1,
29860 .scale = 0.0f,
29861 .type = TestOperandType::FLOAT32,
29862 .zeroPoint = 0
29863 }, { // axis
29864 .channelQuant = {},
29865 .data = TestBuffer::createFromVector<int32_t>({1}),
29866 .dimensions = {},
29867 .isIgnored = false,
29868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29869 .numberOfConsumers = 1,
29870 .scale = 0.0f,
29871 .type = TestOperandType::INT32,
29872 .zeroPoint = 0
29873 }, { // op2
29874 .channelQuant = {},
29875 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29876 .dimensions = {2, 5},
29877 .isIgnored = false,
29878 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29879 .numberOfConsumers = 0,
29880 .scale = 0.00390625f,
29881 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29882 .zeroPoint = 0
29883 }, { // op1_new
29884 .channelQuant = {},
29885 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
29886 .dimensions = {2, 5},
29887 .isIgnored = false,
29888 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29889 .numberOfConsumers = 1,
29890 .scale = 0.25f,
29891 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29892 .zeroPoint = 128
29893 }, { // placeholder180
29894 .channelQuant = {},
29895 .data = TestBuffer::createFromVector<uint8_t>({128}),
29896 .dimensions = {1},
29897 .isIgnored = false,
29898 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29899 .numberOfConsumers = 1,
29900 .scale = 0.25f,
29901 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29902 .zeroPoint = 128
29903 }, { // param198
29904 .channelQuant = {},
29905 .data = TestBuffer::createFromVector<int32_t>({0}),
29906 .dimensions = {},
29907 .isIgnored = false,
29908 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29909 .numberOfConsumers = 1,
29910 .scale = 0.0f,
29911 .type = TestOperandType::INT32,
29912 .zeroPoint = 0
29913 }},
29914 .operations = {{
29915 .inputs = {4, 5, 6},
29916 .outputs = {0},
29917 .type = TestOperationType::ADD
29918 }, {
29919 .inputs = {0, 1, 2},
29920 .outputs = {3},
29921 .type = TestOperationType::SOFTMAX
29922 }},
29923 .outputIndexes = {3}
29924 },
29925 .minSupportedVersion = TestHalVersion::V1_2,
29926 .referenced = {}
29927 };
29928 return model;
29929 }
29930
29931 const auto dummy_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1_all_inputs_as_internal_2", get_test_model_axis_quant8_dim2_axis1_all_inputs_as_internal_2());
29932
29933 } // namespace generated_tests::softmax_v1_2
29934
29935 namespace generated_tests::softmax_v1_2 {
29936
get_test_model_axis_quant8_dim2_axis1_neg_2()29937 const TestModel& get_test_model_axis_quant8_dim2_axis1_neg_2() {
29938 static TestModel model = {
29939 .expectFailure = false,
29940 .expectedMultinomialDistributionTolerance = 0,
29941 .isRelaxed = false,
29942 .main = { // axis
29943 .inputIndexes = {0},
29944 .operands = {{ // op1
29945 .channelQuant = {},
29946 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
29947 .dimensions = {2, 5},
29948 .isIgnored = false,
29949 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29950 .numberOfConsumers = 1,
29951 .scale = 0.25f,
29952 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29953 .zeroPoint = 128
29954 }, { // param3
29955 .channelQuant = {},
29956 .data = TestBuffer::createFromVector<float>({1e-06f}),
29957 .dimensions = {},
29958 .isIgnored = false,
29959 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29960 .numberOfConsumers = 1,
29961 .scale = 0.0f,
29962 .type = TestOperandType::FLOAT32,
29963 .zeroPoint = 0
29964 }, { // axis
29965 .channelQuant = {},
29966 .data = TestBuffer::createFromVector<int32_t>({-1}),
29967 .dimensions = {},
29968 .isIgnored = false,
29969 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
29970 .numberOfConsumers = 1,
29971 .scale = 0.0f,
29972 .type = TestOperandType::INT32,
29973 .zeroPoint = 0
29974 }, { // op2
29975 .channelQuant = {},
29976 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
29977 .dimensions = {2, 5},
29978 .isIgnored = false,
29979 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
29980 .numberOfConsumers = 0,
29981 .scale = 0.00390625f,
29982 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
29983 .zeroPoint = 0
29984 }},
29985 .operations = {{
29986 .inputs = {0, 1, 2},
29987 .outputs = {3},
29988 .type = TestOperationType::SOFTMAX
29989 }},
29990 .outputIndexes = {3}
29991 },
29992 .minSupportedVersion = TestHalVersion::V1_0,
29993 .referenced = {}
29994 };
29995 return model;
29996 }
29997
29998 const auto dummy_test_model_axis_quant8_dim2_axis1_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1_neg_2", get_test_model_axis_quant8_dim2_axis1_neg_2());
29999
30000 } // namespace generated_tests::softmax_v1_2
30001
30002 namespace generated_tests::softmax_v1_2 {
30003
get_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal_2()30004 const TestModel& get_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal_2() {
30005 static TestModel model = {
30006 .expectFailure = false,
30007 .expectedMultinomialDistributionTolerance = 0,
30008 .isRelaxed = false,
30009 .main = { // axis
30010 .inputIndexes = {4},
30011 .operands = {{ // op1
30012 .channelQuant = {},
30013 .data = TestBuffer::createFromVector<uint8_t>({}),
30014 .dimensions = {2, 5},
30015 .isIgnored = false,
30016 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30017 .numberOfConsumers = 1,
30018 .scale = 0.25f,
30019 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30020 .zeroPoint = 128
30021 }, { // param3
30022 .channelQuant = {},
30023 .data = TestBuffer::createFromVector<float>({1e-06f}),
30024 .dimensions = {},
30025 .isIgnored = false,
30026 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30027 .numberOfConsumers = 1,
30028 .scale = 0.0f,
30029 .type = TestOperandType::FLOAT32,
30030 .zeroPoint = 0
30031 }, { // axis
30032 .channelQuant = {},
30033 .data = TestBuffer::createFromVector<int32_t>({-1}),
30034 .dimensions = {},
30035 .isIgnored = false,
30036 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30037 .numberOfConsumers = 1,
30038 .scale = 0.0f,
30039 .type = TestOperandType::INT32,
30040 .zeroPoint = 0
30041 }, { // op2
30042 .channelQuant = {},
30043 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51, 51, 51, 51, 51, 51}),
30044 .dimensions = {2, 5},
30045 .isIgnored = false,
30046 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30047 .numberOfConsumers = 0,
30048 .scale = 0.00390625f,
30049 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30050 .zeroPoint = 0
30051 }, { // op1_new
30052 .channelQuant = {},
30053 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148, 124, 120, 116, 112, 108}),
30054 .dimensions = {2, 5},
30055 .isIgnored = false,
30056 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
30057 .numberOfConsumers = 1,
30058 .scale = 0.25f,
30059 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30060 .zeroPoint = 128
30061 }, { // placeholder181
30062 .channelQuant = {},
30063 .data = TestBuffer::createFromVector<uint8_t>({128}),
30064 .dimensions = {1},
30065 .isIgnored = false,
30066 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30067 .numberOfConsumers = 1,
30068 .scale = 0.25f,
30069 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30070 .zeroPoint = 128
30071 }, { // param199
30072 .channelQuant = {},
30073 .data = TestBuffer::createFromVector<int32_t>({0}),
30074 .dimensions = {},
30075 .isIgnored = false,
30076 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30077 .numberOfConsumers = 1,
30078 .scale = 0.0f,
30079 .type = TestOperandType::INT32,
30080 .zeroPoint = 0
30081 }},
30082 .operations = {{
30083 .inputs = {4, 5, 6},
30084 .outputs = {0},
30085 .type = TestOperationType::ADD
30086 }, {
30087 .inputs = {0, 1, 2},
30088 .outputs = {3},
30089 .type = TestOperationType::SOFTMAX
30090 }},
30091 .outputIndexes = {3}
30092 },
30093 .minSupportedVersion = TestHalVersion::V1_0,
30094 .referenced = {}
30095 };
30096 return model;
30097 }
30098
30099 const auto dummy_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim2_axis1_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim2_axis1_neg_all_inputs_as_internal_2());
30100
30101 } // namespace generated_tests::softmax_v1_2
30102
30103 namespace generated_tests::softmax_v1_2 {
30104
get_test_model_axis_quant8_dim1_axis0_2()30105 const TestModel& get_test_model_axis_quant8_dim1_axis0_2() {
30106 static TestModel model = {
30107 .expectFailure = false,
30108 .expectedMultinomialDistributionTolerance = 0,
30109 .isRelaxed = false,
30110 .main = { // axis
30111 .inputIndexes = {0},
30112 .operands = {{ // op1
30113 .channelQuant = {},
30114 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148}),
30115 .dimensions = {5},
30116 .isIgnored = false,
30117 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
30118 .numberOfConsumers = 1,
30119 .scale = 0.25f,
30120 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30121 .zeroPoint = 128
30122 }, { // param3
30123 .channelQuant = {},
30124 .data = TestBuffer::createFromVector<float>({1e-06f}),
30125 .dimensions = {},
30126 .isIgnored = false,
30127 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30128 .numberOfConsumers = 1,
30129 .scale = 0.0f,
30130 .type = TestOperandType::FLOAT32,
30131 .zeroPoint = 0
30132 }, { // axis
30133 .channelQuant = {},
30134 .data = TestBuffer::createFromVector<int32_t>({0}),
30135 .dimensions = {},
30136 .isIgnored = false,
30137 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30138 .numberOfConsumers = 1,
30139 .scale = 0.0f,
30140 .type = TestOperandType::INT32,
30141 .zeroPoint = 0
30142 }, { // op2
30143 .channelQuant = {},
30144 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51}),
30145 .dimensions = {5},
30146 .isIgnored = false,
30147 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30148 .numberOfConsumers = 0,
30149 .scale = 0.00390625f,
30150 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30151 .zeroPoint = 0
30152 }},
30153 .operations = {{
30154 .inputs = {0, 1, 2},
30155 .outputs = {3},
30156 .type = TestOperationType::SOFTMAX
30157 }},
30158 .outputIndexes = {3}
30159 },
30160 .minSupportedVersion = TestHalVersion::V1_2,
30161 .referenced = {}
30162 };
30163 return model;
30164 }
30165
30166 const auto dummy_test_model_axis_quant8_dim1_axis0_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0_2", get_test_model_axis_quant8_dim1_axis0_2());
30167
30168 } // namespace generated_tests::softmax_v1_2
30169
30170 namespace generated_tests::softmax_v1_2 {
30171
get_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal_2()30172 const TestModel& get_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal_2() {
30173 static TestModel model = {
30174 .expectFailure = false,
30175 .expectedMultinomialDistributionTolerance = 0,
30176 .isRelaxed = false,
30177 .main = { // axis
30178 .inputIndexes = {4},
30179 .operands = {{ // op1
30180 .channelQuant = {},
30181 .data = TestBuffer::createFromVector<uint8_t>({}),
30182 .dimensions = {5},
30183 .isIgnored = false,
30184 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30185 .numberOfConsumers = 1,
30186 .scale = 0.25f,
30187 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30188 .zeroPoint = 128
30189 }, { // param3
30190 .channelQuant = {},
30191 .data = TestBuffer::createFromVector<float>({1e-06f}),
30192 .dimensions = {},
30193 .isIgnored = false,
30194 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30195 .numberOfConsumers = 1,
30196 .scale = 0.0f,
30197 .type = TestOperandType::FLOAT32,
30198 .zeroPoint = 0
30199 }, { // axis
30200 .channelQuant = {},
30201 .data = TestBuffer::createFromVector<int32_t>({0}),
30202 .dimensions = {},
30203 .isIgnored = false,
30204 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30205 .numberOfConsumers = 1,
30206 .scale = 0.0f,
30207 .type = TestOperandType::INT32,
30208 .zeroPoint = 0
30209 }, { // op2
30210 .channelQuant = {},
30211 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51}),
30212 .dimensions = {5},
30213 .isIgnored = false,
30214 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30215 .numberOfConsumers = 0,
30216 .scale = 0.00390625f,
30217 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30218 .zeroPoint = 0
30219 }, { // op1_new
30220 .channelQuant = {},
30221 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148}),
30222 .dimensions = {5},
30223 .isIgnored = false,
30224 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
30225 .numberOfConsumers = 1,
30226 .scale = 0.25f,
30227 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30228 .zeroPoint = 128
30229 }, { // placeholder182
30230 .channelQuant = {},
30231 .data = TestBuffer::createFromVector<uint8_t>({128}),
30232 .dimensions = {1},
30233 .isIgnored = false,
30234 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30235 .numberOfConsumers = 1,
30236 .scale = 0.25f,
30237 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30238 .zeroPoint = 128
30239 }, { // param200
30240 .channelQuant = {},
30241 .data = TestBuffer::createFromVector<int32_t>({0}),
30242 .dimensions = {},
30243 .isIgnored = false,
30244 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30245 .numberOfConsumers = 1,
30246 .scale = 0.0f,
30247 .type = TestOperandType::INT32,
30248 .zeroPoint = 0
30249 }},
30250 .operations = {{
30251 .inputs = {4, 5, 6},
30252 .outputs = {0},
30253 .type = TestOperationType::ADD
30254 }, {
30255 .inputs = {0, 1, 2},
30256 .outputs = {3},
30257 .type = TestOperationType::SOFTMAX
30258 }},
30259 .outputIndexes = {3}
30260 },
30261 .minSupportedVersion = TestHalVersion::V1_2,
30262 .referenced = {}
30263 };
30264 return model;
30265 }
30266
30267 const auto dummy_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0_all_inputs_as_internal_2", get_test_model_axis_quant8_dim1_axis0_all_inputs_as_internal_2());
30268
30269 } // namespace generated_tests::softmax_v1_2
30270
30271 namespace generated_tests::softmax_v1_2 {
30272
get_test_model_axis_quant8_dim1_axis0_neg_2()30273 const TestModel& get_test_model_axis_quant8_dim1_axis0_neg_2() {
30274 static TestModel model = {
30275 .expectFailure = false,
30276 .expectedMultinomialDistributionTolerance = 0,
30277 .isRelaxed = false,
30278 .main = { // axis
30279 .inputIndexes = {0},
30280 .operands = {{ // op1
30281 .channelQuant = {},
30282 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148}),
30283 .dimensions = {5},
30284 .isIgnored = false,
30285 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
30286 .numberOfConsumers = 1,
30287 .scale = 0.25f,
30288 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30289 .zeroPoint = 128
30290 }, { // param3
30291 .channelQuant = {},
30292 .data = TestBuffer::createFromVector<float>({1e-06f}),
30293 .dimensions = {},
30294 .isIgnored = false,
30295 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30296 .numberOfConsumers = 1,
30297 .scale = 0.0f,
30298 .type = TestOperandType::FLOAT32,
30299 .zeroPoint = 0
30300 }, { // axis
30301 .channelQuant = {},
30302 .data = TestBuffer::createFromVector<int32_t>({-1}),
30303 .dimensions = {},
30304 .isIgnored = false,
30305 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30306 .numberOfConsumers = 1,
30307 .scale = 0.0f,
30308 .type = TestOperandType::INT32,
30309 .zeroPoint = 0
30310 }, { // op2
30311 .channelQuant = {},
30312 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51}),
30313 .dimensions = {5},
30314 .isIgnored = false,
30315 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30316 .numberOfConsumers = 0,
30317 .scale = 0.00390625f,
30318 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30319 .zeroPoint = 0
30320 }},
30321 .operations = {{
30322 .inputs = {0, 1, 2},
30323 .outputs = {3},
30324 .type = TestOperationType::SOFTMAX
30325 }},
30326 .outputIndexes = {3}
30327 },
30328 .minSupportedVersion = TestHalVersion::V1_2,
30329 .referenced = {}
30330 };
30331 return model;
30332 }
30333
30334 const auto dummy_test_model_axis_quant8_dim1_axis0_neg_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0_neg_2", get_test_model_axis_quant8_dim1_axis0_neg_2());
30335
30336 } // namespace generated_tests::softmax_v1_2
30337
30338 namespace generated_tests::softmax_v1_2 {
30339
get_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal_2()30340 const TestModel& get_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal_2() {
30341 static TestModel model = {
30342 .expectFailure = false,
30343 .expectedMultinomialDistributionTolerance = 0,
30344 .isRelaxed = false,
30345 .main = { // axis
30346 .inputIndexes = {4},
30347 .operands = {{ // op1
30348 .channelQuant = {},
30349 .data = TestBuffer::createFromVector<uint8_t>({}),
30350 .dimensions = {5},
30351 .isIgnored = false,
30352 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30353 .numberOfConsumers = 1,
30354 .scale = 0.25f,
30355 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30356 .zeroPoint = 128
30357 }, { // param3
30358 .channelQuant = {},
30359 .data = TestBuffer::createFromVector<float>({1e-06f}),
30360 .dimensions = {},
30361 .isIgnored = false,
30362 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30363 .numberOfConsumers = 1,
30364 .scale = 0.0f,
30365 .type = TestOperandType::FLOAT32,
30366 .zeroPoint = 0
30367 }, { // axis
30368 .channelQuant = {},
30369 .data = TestBuffer::createFromVector<int32_t>({-1}),
30370 .dimensions = {},
30371 .isIgnored = false,
30372 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30373 .numberOfConsumers = 1,
30374 .scale = 0.0f,
30375 .type = TestOperandType::INT32,
30376 .zeroPoint = 0
30377 }, { // op2
30378 .channelQuant = {},
30379 .data = TestBuffer::createFromVector<uint8_t>({51, 51, 51, 51, 51}),
30380 .dimensions = {5},
30381 .isIgnored = false,
30382 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30383 .numberOfConsumers = 0,
30384 .scale = 0.00390625f,
30385 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30386 .zeroPoint = 0
30387 }, { // op1_new
30388 .channelQuant = {},
30389 .data = TestBuffer::createFromVector<uint8_t>({132, 136, 140, 144, 148}),
30390 .dimensions = {5},
30391 .isIgnored = false,
30392 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
30393 .numberOfConsumers = 1,
30394 .scale = 0.25f,
30395 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30396 .zeroPoint = 128
30397 }, { // placeholder183
30398 .channelQuant = {},
30399 .data = TestBuffer::createFromVector<uint8_t>({128}),
30400 .dimensions = {1},
30401 .isIgnored = false,
30402 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30403 .numberOfConsumers = 1,
30404 .scale = 0.25f,
30405 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
30406 .zeroPoint = 128
30407 }, { // param201
30408 .channelQuant = {},
30409 .data = TestBuffer::createFromVector<int32_t>({0}),
30410 .dimensions = {},
30411 .isIgnored = false,
30412 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30413 .numberOfConsumers = 1,
30414 .scale = 0.0f,
30415 .type = TestOperandType::INT32,
30416 .zeroPoint = 0
30417 }},
30418 .operations = {{
30419 .inputs = {4, 5, 6},
30420 .outputs = {0},
30421 .type = TestOperationType::ADD
30422 }, {
30423 .inputs = {0, 1, 2},
30424 .outputs = {3},
30425 .type = TestOperationType::SOFTMAX
30426 }},
30427 .outputIndexes = {3}
30428 },
30429 .minSupportedVersion = TestHalVersion::V1_2,
30430 .referenced = {}
30431 };
30432 return model;
30433 }
30434
30435 const auto dummy_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal_2 = TestModelManager::get().add("softmax_v1_2_axis_quant8_dim1_axis0_neg_all_inputs_as_internal_2", get_test_model_axis_quant8_dim1_axis0_neg_all_inputs_as_internal_2());
30436
30437 } // namespace generated_tests::softmax_v1_2
30438
30439 namespace generated_tests::softmax_v1_2 {
30440
get_test_model_zero_sized()30441 const TestModel& get_test_model_zero_sized() {
30442 static TestModel model = {
30443 .expectFailure = false,
30444 .expectedMultinomialDistributionTolerance = 0,
30445 .isRelaxed = false,
30446 .main = { // zero_sized
30447 .inputIndexes = {13},
30448 .operands = {{ // scores
30449 .channelQuant = {},
30450 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
30451 .dimensions = {1, 2},
30452 .isIgnored = false,
30453 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30454 .numberOfConsumers = 1,
30455 .scale = 0.0f,
30456 .type = TestOperandType::TENSOR_FLOAT32,
30457 .zeroPoint = 0
30458 }, { // roi
30459 .channelQuant = {},
30460 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
30461 .dimensions = {1, 8},
30462 .isIgnored = false,
30463 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30464 .numberOfConsumers = 1,
30465 .scale = 0.0f,
30466 .type = TestOperandType::TENSOR_FLOAT32,
30467 .zeroPoint = 0
30468 }, { // param4
30469 .channelQuant = {},
30470 .data = TestBuffer::createFromVector<int32_t>({0}),
30471 .dimensions = {1},
30472 .isIgnored = false,
30473 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30474 .numberOfConsumers = 1,
30475 .scale = 0.0f,
30476 .type = TestOperandType::TENSOR_INT32,
30477 .zeroPoint = 0
30478 }, { // param5
30479 .channelQuant = {},
30480 .data = TestBuffer::createFromVector<float>({0.3f}),
30481 .dimensions = {},
30482 .isIgnored = false,
30483 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30484 .numberOfConsumers = 1,
30485 .scale = 0.0f,
30486 .type = TestOperandType::FLOAT32,
30487 .zeroPoint = 0
30488 }, { // param6
30489 .channelQuant = {},
30490 .data = TestBuffer::createFromVector<int32_t>({-1}),
30491 .dimensions = {},
30492 .isIgnored = false,
30493 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30494 .numberOfConsumers = 1,
30495 .scale = 0.0f,
30496 .type = TestOperandType::INT32,
30497 .zeroPoint = 0
30498 }, { // param7
30499 .channelQuant = {},
30500 .data = TestBuffer::createFromVector<int32_t>({0}),
30501 .dimensions = {},
30502 .isIgnored = false,
30503 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30504 .numberOfConsumers = 1,
30505 .scale = 0.0f,
30506 .type = TestOperandType::INT32,
30507 .zeroPoint = 0
30508 }, { // param8
30509 .channelQuant = {},
30510 .data = TestBuffer::createFromVector<float>({0.4f}),
30511 .dimensions = {},
30512 .isIgnored = false,
30513 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30514 .numberOfConsumers = 1,
30515 .scale = 0.0f,
30516 .type = TestOperandType::FLOAT32,
30517 .zeroPoint = 0
30518 }, { // param9
30519 .channelQuant = {},
30520 .data = TestBuffer::createFromVector<float>({1.0f}),
30521 .dimensions = {},
30522 .isIgnored = false,
30523 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30524 .numberOfConsumers = 1,
30525 .scale = 0.0f,
30526 .type = TestOperandType::FLOAT32,
30527 .zeroPoint = 0
30528 }, { // param10
30529 .channelQuant = {},
30530 .data = TestBuffer::createFromVector<float>({0.3f}),
30531 .dimensions = {},
30532 .isIgnored = false,
30533 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30534 .numberOfConsumers = 1,
30535 .scale = 0.0f,
30536 .type = TestOperandType::FLOAT32,
30537 .zeroPoint = 0
30538 }, { // scoresOut
30539 .channelQuant = {},
30540 .data = TestBuffer::createFromVector<float>({}),
30541 .dimensions = {0},
30542 .isIgnored = false,
30543 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30544 .numberOfConsumers = 0,
30545 .scale = 0.0f,
30546 .type = TestOperandType::TENSOR_FLOAT32,
30547 .zeroPoint = 0
30548 }, { // roiOut
30549 .channelQuant = {},
30550 .data = TestBuffer::createFromVector<float>({}),
30551 .dimensions = {0, 4},
30552 .isIgnored = false,
30553 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30554 .numberOfConsumers = 1,
30555 .scale = 0.0f,
30556 .type = TestOperandType::TENSOR_FLOAT32,
30557 .zeroPoint = 0
30558 }, { // classesOut
30559 .channelQuant = {},
30560 .data = TestBuffer::createFromVector<int32_t>({}),
30561 .dimensions = {0},
30562 .isIgnored = false,
30563 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30564 .numberOfConsumers = 0,
30565 .scale = 0.0f,
30566 .type = TestOperandType::TENSOR_INT32,
30567 .zeroPoint = 0
30568 }, { // batchSplitOut
30569 .channelQuant = {},
30570 .data = TestBuffer::createFromVector<int32_t>({}),
30571 .dimensions = {0},
30572 .isIgnored = false,
30573 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30574 .numberOfConsumers = 1,
30575 .scale = 0.0f,
30576 .type = TestOperandType::TENSOR_INT32,
30577 .zeroPoint = 0
30578 }, { // in
30579 .channelQuant = {},
30580 .data = TestBuffer::createFromVector<float>({1.0f}),
30581 .dimensions = {1, 1, 1, 1},
30582 .isIgnored = false,
30583 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
30584 .numberOfConsumers = 1,
30585 .scale = 0.0f,
30586 .type = TestOperandType::TENSOR_FLOAT32,
30587 .zeroPoint = 0
30588 }, { // param11
30589 .channelQuant = {},
30590 .data = TestBuffer::createFromVector<int32_t>({2}),
30591 .dimensions = {},
30592 .isIgnored = false,
30593 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30594 .numberOfConsumers = 1,
30595 .scale = 0.0f,
30596 .type = TestOperandType::INT32,
30597 .zeroPoint = 0
30598 }, { // param12
30599 .channelQuant = {},
30600 .data = TestBuffer::createFromVector<int32_t>({2}),
30601 .dimensions = {},
30602 .isIgnored = false,
30603 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30604 .numberOfConsumers = 1,
30605 .scale = 0.0f,
30606 .type = TestOperandType::INT32,
30607 .zeroPoint = 0
30608 }, { // param13
30609 .channelQuant = {},
30610 .data = TestBuffer::createFromVector<float>({2.0f}),
30611 .dimensions = {},
30612 .isIgnored = false,
30613 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30614 .numberOfConsumers = 1,
30615 .scale = 0.0f,
30616 .type = TestOperandType::FLOAT32,
30617 .zeroPoint = 0
30618 }, { // param14
30619 .channelQuant = {},
30620 .data = TestBuffer::createFromVector<float>({2.0f}),
30621 .dimensions = {},
30622 .isIgnored = false,
30623 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30624 .numberOfConsumers = 1,
30625 .scale = 0.0f,
30626 .type = TestOperandType::FLOAT32,
30627 .zeroPoint = 0
30628 }, { // param15
30629 .channelQuant = {},
30630 .data = TestBuffer::createFromVector<int32_t>({4}),
30631 .dimensions = {},
30632 .isIgnored = false,
30633 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30634 .numberOfConsumers = 1,
30635 .scale = 0.0f,
30636 .type = TestOperandType::INT32,
30637 .zeroPoint = 0
30638 }, { // param16
30639 .channelQuant = {},
30640 .data = TestBuffer::createFromVector<int32_t>({4}),
30641 .dimensions = {},
30642 .isIgnored = false,
30643 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30644 .numberOfConsumers = 1,
30645 .scale = 0.0f,
30646 .type = TestOperandType::INT32,
30647 .zeroPoint = 0
30648 }, { // layout
30649 .channelQuant = {},
30650 .data = TestBuffer::createFromVector<bool8>({false}),
30651 .dimensions = {},
30652 .isIgnored = false,
30653 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30654 .numberOfConsumers = 1,
30655 .scale = 0.0f,
30656 .type = TestOperandType::BOOL,
30657 .zeroPoint = 0
30658 }, { // featureMap
30659 .channelQuant = {},
30660 .data = TestBuffer::createFromVector<float>({}),
30661 .dimensions = {0, 2, 2, 1},
30662 .isIgnored = false,
30663 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30664 .numberOfConsumers = 1,
30665 .scale = 0.0f,
30666 .type = TestOperandType::TENSOR_FLOAT32,
30667 .zeroPoint = 0
30668 }, { // param17
30669 .channelQuant = {},
30670 .data = TestBuffer::createFromVector<float>({1.0f}),
30671 .dimensions = {},
30672 .isIgnored = false,
30673 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30674 .numberOfConsumers = 1,
30675 .scale = 0.0f,
30676 .type = TestOperandType::FLOAT32,
30677 .zeroPoint = 0
30678 }, { // out
30679 .channelQuant = {},
30680 .data = TestBuffer::createFromVector<float>({}),
30681 .dimensions = {0, 2, 2, 1},
30682 .isIgnored = false,
30683 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30684 .numberOfConsumers = 0,
30685 .scale = 0.0f,
30686 .type = TestOperandType::TENSOR_FLOAT32,
30687 .zeroPoint = 0
30688 }},
30689 .operations = {{
30690 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
30691 .outputs = {9, 10, 11, 12},
30692 .type = TestOperationType::BOX_WITH_NMS_LIMIT
30693 }, {
30694 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
30695 .outputs = {21},
30696 .type = TestOperationType::ROI_ALIGN
30697 }, {
30698 .inputs = {21, 22},
30699 .outputs = {23},
30700 .type = TestOperationType::SOFTMAX
30701 }},
30702 .outputIndexes = {9, 11, 23}
30703 },
30704 .minSupportedVersion = TestHalVersion::V1_2,
30705 .referenced = {}
30706 };
30707 return model;
30708 }
30709
30710 const auto dummy_test_model_zero_sized = TestModelManager::get().add("softmax_v1_2_zero_sized", get_test_model_zero_sized());
30711
30712 } // namespace generated_tests::softmax_v1_2
30713
30714 namespace generated_tests::softmax_v1_2 {
30715
get_test_model_zero_sized_relaxed()30716 const TestModel& get_test_model_zero_sized_relaxed() {
30717 static TestModel model = {
30718 .expectFailure = false,
30719 .expectedMultinomialDistributionTolerance = 0,
30720 .isRelaxed = true,
30721 .main = { // zero_sized
30722 .inputIndexes = {13},
30723 .operands = {{ // scores
30724 .channelQuant = {},
30725 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
30726 .dimensions = {1, 2},
30727 .isIgnored = false,
30728 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30729 .numberOfConsumers = 1,
30730 .scale = 0.0f,
30731 .type = TestOperandType::TENSOR_FLOAT32,
30732 .zeroPoint = 0
30733 }, { // roi
30734 .channelQuant = {},
30735 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
30736 .dimensions = {1, 8},
30737 .isIgnored = false,
30738 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30739 .numberOfConsumers = 1,
30740 .scale = 0.0f,
30741 .type = TestOperandType::TENSOR_FLOAT32,
30742 .zeroPoint = 0
30743 }, { // param4
30744 .channelQuant = {},
30745 .data = TestBuffer::createFromVector<int32_t>({0}),
30746 .dimensions = {1},
30747 .isIgnored = false,
30748 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30749 .numberOfConsumers = 1,
30750 .scale = 0.0f,
30751 .type = TestOperandType::TENSOR_INT32,
30752 .zeroPoint = 0
30753 }, { // param5
30754 .channelQuant = {},
30755 .data = TestBuffer::createFromVector<float>({0.3f}),
30756 .dimensions = {},
30757 .isIgnored = false,
30758 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30759 .numberOfConsumers = 1,
30760 .scale = 0.0f,
30761 .type = TestOperandType::FLOAT32,
30762 .zeroPoint = 0
30763 }, { // param6
30764 .channelQuant = {},
30765 .data = TestBuffer::createFromVector<int32_t>({-1}),
30766 .dimensions = {},
30767 .isIgnored = false,
30768 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30769 .numberOfConsumers = 1,
30770 .scale = 0.0f,
30771 .type = TestOperandType::INT32,
30772 .zeroPoint = 0
30773 }, { // param7
30774 .channelQuant = {},
30775 .data = TestBuffer::createFromVector<int32_t>({0}),
30776 .dimensions = {},
30777 .isIgnored = false,
30778 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30779 .numberOfConsumers = 1,
30780 .scale = 0.0f,
30781 .type = TestOperandType::INT32,
30782 .zeroPoint = 0
30783 }, { // param8
30784 .channelQuant = {},
30785 .data = TestBuffer::createFromVector<float>({0.4f}),
30786 .dimensions = {},
30787 .isIgnored = false,
30788 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30789 .numberOfConsumers = 1,
30790 .scale = 0.0f,
30791 .type = TestOperandType::FLOAT32,
30792 .zeroPoint = 0
30793 }, { // param9
30794 .channelQuant = {},
30795 .data = TestBuffer::createFromVector<float>({1.0f}),
30796 .dimensions = {},
30797 .isIgnored = false,
30798 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30799 .numberOfConsumers = 1,
30800 .scale = 0.0f,
30801 .type = TestOperandType::FLOAT32,
30802 .zeroPoint = 0
30803 }, { // param10
30804 .channelQuant = {},
30805 .data = TestBuffer::createFromVector<float>({0.3f}),
30806 .dimensions = {},
30807 .isIgnored = false,
30808 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30809 .numberOfConsumers = 1,
30810 .scale = 0.0f,
30811 .type = TestOperandType::FLOAT32,
30812 .zeroPoint = 0
30813 }, { // scoresOut
30814 .channelQuant = {},
30815 .data = TestBuffer::createFromVector<float>({}),
30816 .dimensions = {0},
30817 .isIgnored = false,
30818 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30819 .numberOfConsumers = 0,
30820 .scale = 0.0f,
30821 .type = TestOperandType::TENSOR_FLOAT32,
30822 .zeroPoint = 0
30823 }, { // roiOut
30824 .channelQuant = {},
30825 .data = TestBuffer::createFromVector<float>({}),
30826 .dimensions = {0, 4},
30827 .isIgnored = false,
30828 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30829 .numberOfConsumers = 1,
30830 .scale = 0.0f,
30831 .type = TestOperandType::TENSOR_FLOAT32,
30832 .zeroPoint = 0
30833 }, { // classesOut
30834 .channelQuant = {},
30835 .data = TestBuffer::createFromVector<int32_t>({}),
30836 .dimensions = {0},
30837 .isIgnored = false,
30838 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30839 .numberOfConsumers = 0,
30840 .scale = 0.0f,
30841 .type = TestOperandType::TENSOR_INT32,
30842 .zeroPoint = 0
30843 }, { // batchSplitOut
30844 .channelQuant = {},
30845 .data = TestBuffer::createFromVector<int32_t>({}),
30846 .dimensions = {0},
30847 .isIgnored = false,
30848 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30849 .numberOfConsumers = 1,
30850 .scale = 0.0f,
30851 .type = TestOperandType::TENSOR_INT32,
30852 .zeroPoint = 0
30853 }, { // in
30854 .channelQuant = {},
30855 .data = TestBuffer::createFromVector<float>({1.0f}),
30856 .dimensions = {1, 1, 1, 1},
30857 .isIgnored = false,
30858 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
30859 .numberOfConsumers = 1,
30860 .scale = 0.0f,
30861 .type = TestOperandType::TENSOR_FLOAT32,
30862 .zeroPoint = 0
30863 }, { // param11
30864 .channelQuant = {},
30865 .data = TestBuffer::createFromVector<int32_t>({2}),
30866 .dimensions = {},
30867 .isIgnored = false,
30868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30869 .numberOfConsumers = 1,
30870 .scale = 0.0f,
30871 .type = TestOperandType::INT32,
30872 .zeroPoint = 0
30873 }, { // param12
30874 .channelQuant = {},
30875 .data = TestBuffer::createFromVector<int32_t>({2}),
30876 .dimensions = {},
30877 .isIgnored = false,
30878 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30879 .numberOfConsumers = 1,
30880 .scale = 0.0f,
30881 .type = TestOperandType::INT32,
30882 .zeroPoint = 0
30883 }, { // param13
30884 .channelQuant = {},
30885 .data = TestBuffer::createFromVector<float>({2.0f}),
30886 .dimensions = {},
30887 .isIgnored = false,
30888 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30889 .numberOfConsumers = 1,
30890 .scale = 0.0f,
30891 .type = TestOperandType::FLOAT32,
30892 .zeroPoint = 0
30893 }, { // param14
30894 .channelQuant = {},
30895 .data = TestBuffer::createFromVector<float>({2.0f}),
30896 .dimensions = {},
30897 .isIgnored = false,
30898 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30899 .numberOfConsumers = 1,
30900 .scale = 0.0f,
30901 .type = TestOperandType::FLOAT32,
30902 .zeroPoint = 0
30903 }, { // param15
30904 .channelQuant = {},
30905 .data = TestBuffer::createFromVector<int32_t>({4}),
30906 .dimensions = {},
30907 .isIgnored = false,
30908 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30909 .numberOfConsumers = 1,
30910 .scale = 0.0f,
30911 .type = TestOperandType::INT32,
30912 .zeroPoint = 0
30913 }, { // param16
30914 .channelQuant = {},
30915 .data = TestBuffer::createFromVector<int32_t>({4}),
30916 .dimensions = {},
30917 .isIgnored = false,
30918 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30919 .numberOfConsumers = 1,
30920 .scale = 0.0f,
30921 .type = TestOperandType::INT32,
30922 .zeroPoint = 0
30923 }, { // layout
30924 .channelQuant = {},
30925 .data = TestBuffer::createFromVector<bool8>({false}),
30926 .dimensions = {},
30927 .isIgnored = false,
30928 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30929 .numberOfConsumers = 1,
30930 .scale = 0.0f,
30931 .type = TestOperandType::BOOL,
30932 .zeroPoint = 0
30933 }, { // featureMap
30934 .channelQuant = {},
30935 .data = TestBuffer::createFromVector<float>({}),
30936 .dimensions = {0, 2, 2, 1},
30937 .isIgnored = false,
30938 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
30939 .numberOfConsumers = 1,
30940 .scale = 0.0f,
30941 .type = TestOperandType::TENSOR_FLOAT32,
30942 .zeroPoint = 0
30943 }, { // param17
30944 .channelQuant = {},
30945 .data = TestBuffer::createFromVector<float>({1.0f}),
30946 .dimensions = {},
30947 .isIgnored = false,
30948 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
30949 .numberOfConsumers = 1,
30950 .scale = 0.0f,
30951 .type = TestOperandType::FLOAT32,
30952 .zeroPoint = 0
30953 }, { // out
30954 .channelQuant = {},
30955 .data = TestBuffer::createFromVector<float>({}),
30956 .dimensions = {0, 2, 2, 1},
30957 .isIgnored = false,
30958 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
30959 .numberOfConsumers = 0,
30960 .scale = 0.0f,
30961 .type = TestOperandType::TENSOR_FLOAT32,
30962 .zeroPoint = 0
30963 }},
30964 .operations = {{
30965 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
30966 .outputs = {9, 10, 11, 12},
30967 .type = TestOperationType::BOX_WITH_NMS_LIMIT
30968 }, {
30969 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
30970 .outputs = {21},
30971 .type = TestOperationType::ROI_ALIGN
30972 }, {
30973 .inputs = {21, 22},
30974 .outputs = {23},
30975 .type = TestOperationType::SOFTMAX
30976 }},
30977 .outputIndexes = {9, 11, 23}
30978 },
30979 .minSupportedVersion = TestHalVersion::UNKNOWN,
30980 .referenced = {}
30981 };
30982 return model;
30983 }
30984
30985 const auto dummy_test_model_zero_sized_relaxed = TestModelManager::get().add("softmax_v1_2_zero_sized_relaxed", get_test_model_zero_sized_relaxed());
30986
30987 } // namespace generated_tests::softmax_v1_2
30988
30989 namespace generated_tests::softmax_v1_2 {
30990
get_test_model_zero_sized_quant8()30991 const TestModel& get_test_model_zero_sized_quant8() {
30992 static TestModel model = {
30993 .expectFailure = false,
30994 .expectedMultinomialDistributionTolerance = 0,
30995 .isRelaxed = false,
30996 .main = { // zero_sized
30997 .inputIndexes = {13},
30998 .operands = {{ // scores
30999 .channelQuant = {},
31000 .data = TestBuffer::createFromVector<uint8_t>({137, 129}),
31001 .dimensions = {1, 2},
31002 .isIgnored = false,
31003 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31004 .numberOfConsumers = 1,
31005 .scale = 0.1f,
31006 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
31007 .zeroPoint = 128
31008 }, { // roi
31009 .channelQuant = {},
31010 .data = TestBuffer::createFromVector<uint16_t>({8, 8, 80, 80, 0, 0, 80, 80}),
31011 .dimensions = {1, 8},
31012 .isIgnored = false,
31013 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31014 .numberOfConsumers = 1,
31015 .scale = 0.125f,
31016 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
31017 .zeroPoint = 0
31018 }, { // param4
31019 .channelQuant = {},
31020 .data = TestBuffer::createFromVector<int32_t>({0}),
31021 .dimensions = {1},
31022 .isIgnored = false,
31023 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31024 .numberOfConsumers = 1,
31025 .scale = 0.0f,
31026 .type = TestOperandType::TENSOR_INT32,
31027 .zeroPoint = 0
31028 }, { // param5
31029 .channelQuant = {},
31030 .data = TestBuffer::createFromVector<float>({0.3f}),
31031 .dimensions = {},
31032 .isIgnored = false,
31033 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31034 .numberOfConsumers = 1,
31035 .scale = 0.0f,
31036 .type = TestOperandType::FLOAT32,
31037 .zeroPoint = 0
31038 }, { // param6
31039 .channelQuant = {},
31040 .data = TestBuffer::createFromVector<int32_t>({-1}),
31041 .dimensions = {},
31042 .isIgnored = false,
31043 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31044 .numberOfConsumers = 1,
31045 .scale = 0.0f,
31046 .type = TestOperandType::INT32,
31047 .zeroPoint = 0
31048 }, { // param7
31049 .channelQuant = {},
31050 .data = TestBuffer::createFromVector<int32_t>({0}),
31051 .dimensions = {},
31052 .isIgnored = false,
31053 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31054 .numberOfConsumers = 1,
31055 .scale = 0.0f,
31056 .type = TestOperandType::INT32,
31057 .zeroPoint = 0
31058 }, { // param8
31059 .channelQuant = {},
31060 .data = TestBuffer::createFromVector<float>({0.4f}),
31061 .dimensions = {},
31062 .isIgnored = false,
31063 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31064 .numberOfConsumers = 1,
31065 .scale = 0.0f,
31066 .type = TestOperandType::FLOAT32,
31067 .zeroPoint = 0
31068 }, { // param9
31069 .channelQuant = {},
31070 .data = TestBuffer::createFromVector<float>({1.0f}),
31071 .dimensions = {},
31072 .isIgnored = false,
31073 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31074 .numberOfConsumers = 1,
31075 .scale = 0.0f,
31076 .type = TestOperandType::FLOAT32,
31077 .zeroPoint = 0
31078 }, { // param10
31079 .channelQuant = {},
31080 .data = TestBuffer::createFromVector<float>({0.3f}),
31081 .dimensions = {},
31082 .isIgnored = false,
31083 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31084 .numberOfConsumers = 1,
31085 .scale = 0.0f,
31086 .type = TestOperandType::FLOAT32,
31087 .zeroPoint = 0
31088 }, { // scoresOut
31089 .channelQuant = {},
31090 .data = TestBuffer::createFromVector<uint8_t>({}),
31091 .dimensions = {0},
31092 .isIgnored = false,
31093 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
31094 .numberOfConsumers = 0,
31095 .scale = 0.1f,
31096 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
31097 .zeroPoint = 128
31098 }, { // roiOut
31099 .channelQuant = {},
31100 .data = TestBuffer::createFromVector<uint16_t>({}),
31101 .dimensions = {0, 4},
31102 .isIgnored = false,
31103 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
31104 .numberOfConsumers = 1,
31105 .scale = 0.125f,
31106 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
31107 .zeroPoint = 0
31108 }, { // classesOut
31109 .channelQuant = {},
31110 .data = TestBuffer::createFromVector<int32_t>({}),
31111 .dimensions = {0},
31112 .isIgnored = false,
31113 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
31114 .numberOfConsumers = 0,
31115 .scale = 0.0f,
31116 .type = TestOperandType::TENSOR_INT32,
31117 .zeroPoint = 0
31118 }, { // batchSplitOut
31119 .channelQuant = {},
31120 .data = TestBuffer::createFromVector<int32_t>({}),
31121 .dimensions = {0},
31122 .isIgnored = false,
31123 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
31124 .numberOfConsumers = 1,
31125 .scale = 0.0f,
31126 .type = TestOperandType::TENSOR_INT32,
31127 .zeroPoint = 0
31128 }, { // in
31129 .channelQuant = {},
31130 .data = TestBuffer::createFromVector<uint8_t>({138}),
31131 .dimensions = {1, 1, 1, 1},
31132 .isIgnored = false,
31133 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
31134 .numberOfConsumers = 1,
31135 .scale = 0.1f,
31136 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
31137 .zeroPoint = 128
31138 }, { // param11
31139 .channelQuant = {},
31140 .data = TestBuffer::createFromVector<int32_t>({2}),
31141 .dimensions = {},
31142 .isIgnored = false,
31143 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31144 .numberOfConsumers = 1,
31145 .scale = 0.0f,
31146 .type = TestOperandType::INT32,
31147 .zeroPoint = 0
31148 }, { // param12
31149 .channelQuant = {},
31150 .data = TestBuffer::createFromVector<int32_t>({2}),
31151 .dimensions = {},
31152 .isIgnored = false,
31153 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31154 .numberOfConsumers = 1,
31155 .scale = 0.0f,
31156 .type = TestOperandType::INT32,
31157 .zeroPoint = 0
31158 }, { // param13
31159 .channelQuant = {},
31160 .data = TestBuffer::createFromVector<float>({2.0f}),
31161 .dimensions = {},
31162 .isIgnored = false,
31163 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31164 .numberOfConsumers = 1,
31165 .scale = 0.0f,
31166 .type = TestOperandType::FLOAT32,
31167 .zeroPoint = 0
31168 }, { // param14
31169 .channelQuant = {},
31170 .data = TestBuffer::createFromVector<float>({2.0f}),
31171 .dimensions = {},
31172 .isIgnored = false,
31173 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31174 .numberOfConsumers = 1,
31175 .scale = 0.0f,
31176 .type = TestOperandType::FLOAT32,
31177 .zeroPoint = 0
31178 }, { // param15
31179 .channelQuant = {},
31180 .data = TestBuffer::createFromVector<int32_t>({4}),
31181 .dimensions = {},
31182 .isIgnored = false,
31183 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31184 .numberOfConsumers = 1,
31185 .scale = 0.0f,
31186 .type = TestOperandType::INT32,
31187 .zeroPoint = 0
31188 }, { // param16
31189 .channelQuant = {},
31190 .data = TestBuffer::createFromVector<int32_t>({4}),
31191 .dimensions = {},
31192 .isIgnored = false,
31193 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31194 .numberOfConsumers = 1,
31195 .scale = 0.0f,
31196 .type = TestOperandType::INT32,
31197 .zeroPoint = 0
31198 }, { // layout
31199 .channelQuant = {},
31200 .data = TestBuffer::createFromVector<bool8>({false}),
31201 .dimensions = {},
31202 .isIgnored = false,
31203 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31204 .numberOfConsumers = 1,
31205 .scale = 0.0f,
31206 .type = TestOperandType::BOOL,
31207 .zeroPoint = 0
31208 }, { // featureMap
31209 .channelQuant = {},
31210 .data = TestBuffer::createFromVector<uint8_t>({}),
31211 .dimensions = {0, 2, 2, 1},
31212 .isIgnored = false,
31213 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
31214 .numberOfConsumers = 1,
31215 .scale = 0.1f,
31216 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
31217 .zeroPoint = 128
31218 }, { // param17
31219 .channelQuant = {},
31220 .data = TestBuffer::createFromVector<float>({1.0f}),
31221 .dimensions = {},
31222 .isIgnored = false,
31223 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31224 .numberOfConsumers = 1,
31225 .scale = 0.0f,
31226 .type = TestOperandType::FLOAT32,
31227 .zeroPoint = 0
31228 }, { // out
31229 .channelQuant = {},
31230 .data = TestBuffer::createFromVector<uint8_t>({}),
31231 .dimensions = {0, 2, 2, 1},
31232 .isIgnored = false,
31233 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
31234 .numberOfConsumers = 0,
31235 .scale = 0.00390625f,
31236 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
31237 .zeroPoint = 0
31238 }},
31239 .operations = {{
31240 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
31241 .outputs = {9, 10, 11, 12},
31242 .type = TestOperationType::BOX_WITH_NMS_LIMIT
31243 }, {
31244 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
31245 .outputs = {21},
31246 .type = TestOperationType::ROI_ALIGN
31247 }, {
31248 .inputs = {21, 22},
31249 .outputs = {23},
31250 .type = TestOperationType::SOFTMAX
31251 }},
31252 .outputIndexes = {9, 11, 23}
31253 },
31254 .minSupportedVersion = TestHalVersion::V1_2,
31255 .referenced = {}
31256 };
31257 return model;
31258 }
31259
31260 const auto dummy_test_model_zero_sized_quant8 = TestModelManager::get().add("softmax_v1_2_zero_sized_quant8", get_test_model_zero_sized_quant8());
31261
31262 } // namespace generated_tests::softmax_v1_2
31263
31264 namespace generated_tests::softmax_v1_2 {
31265
get_test_model_zero_sized_float16()31266 const TestModel& get_test_model_zero_sized_float16() {
31267 static TestModel model = {
31268 .expectFailure = false,
31269 .expectedMultinomialDistributionTolerance = 0,
31270 .isRelaxed = false,
31271 .main = { // zero_sized
31272 .inputIndexes = {13},
31273 .operands = {{ // scores
31274 .channelQuant = {},
31275 .data = TestBuffer::createFromVector<_Float16>({0.8999999761581421f, 0.10000000149011612f}),
31276 .dimensions = {1, 2},
31277 .isIgnored = false,
31278 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31279 .numberOfConsumers = 1,
31280 .scale = 0.0f,
31281 .type = TestOperandType::TENSOR_FLOAT16,
31282 .zeroPoint = 0
31283 }, { // roi
31284 .channelQuant = {},
31285 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
31286 .dimensions = {1, 8},
31287 .isIgnored = false,
31288 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31289 .numberOfConsumers = 1,
31290 .scale = 0.0f,
31291 .type = TestOperandType::TENSOR_FLOAT16,
31292 .zeroPoint = 0
31293 }, { // param4
31294 .channelQuant = {},
31295 .data = TestBuffer::createFromVector<int32_t>({0}),
31296 .dimensions = {1},
31297 .isIgnored = false,
31298 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31299 .numberOfConsumers = 1,
31300 .scale = 0.0f,
31301 .type = TestOperandType::TENSOR_INT32,
31302 .zeroPoint = 0
31303 }, { // param5
31304 .channelQuant = {},
31305 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
31306 .dimensions = {},
31307 .isIgnored = false,
31308 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31309 .numberOfConsumers = 1,
31310 .scale = 0.0f,
31311 .type = TestOperandType::FLOAT16,
31312 .zeroPoint = 0
31313 }, { // param6
31314 .channelQuant = {},
31315 .data = TestBuffer::createFromVector<int32_t>({-1}),
31316 .dimensions = {},
31317 .isIgnored = false,
31318 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31319 .numberOfConsumers = 1,
31320 .scale = 0.0f,
31321 .type = TestOperandType::INT32,
31322 .zeroPoint = 0
31323 }, { // param7
31324 .channelQuant = {},
31325 .data = TestBuffer::createFromVector<int32_t>({0}),
31326 .dimensions = {},
31327 .isIgnored = false,
31328 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31329 .numberOfConsumers = 1,
31330 .scale = 0.0f,
31331 .type = TestOperandType::INT32,
31332 .zeroPoint = 0
31333 }, { // param8
31334 .channelQuant = {},
31335 .data = TestBuffer::createFromVector<_Float16>({0.4000000059604645f}),
31336 .dimensions = {},
31337 .isIgnored = false,
31338 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31339 .numberOfConsumers = 1,
31340 .scale = 0.0f,
31341 .type = TestOperandType::FLOAT16,
31342 .zeroPoint = 0
31343 }, { // param9
31344 .channelQuant = {},
31345 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
31346 .dimensions = {},
31347 .isIgnored = false,
31348 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31349 .numberOfConsumers = 1,
31350 .scale = 0.0f,
31351 .type = TestOperandType::FLOAT16,
31352 .zeroPoint = 0
31353 }, { // param10
31354 .channelQuant = {},
31355 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
31356 .dimensions = {},
31357 .isIgnored = false,
31358 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31359 .numberOfConsumers = 1,
31360 .scale = 0.0f,
31361 .type = TestOperandType::FLOAT16,
31362 .zeroPoint = 0
31363 }, { // scoresOut
31364 .channelQuant = {},
31365 .data = TestBuffer::createFromVector<_Float16>({}),
31366 .dimensions = {0},
31367 .isIgnored = false,
31368 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
31369 .numberOfConsumers = 0,
31370 .scale = 0.0f,
31371 .type = TestOperandType::TENSOR_FLOAT16,
31372 .zeroPoint = 0
31373 }, { // roiOut
31374 .channelQuant = {},
31375 .data = TestBuffer::createFromVector<_Float16>({}),
31376 .dimensions = {0, 4},
31377 .isIgnored = false,
31378 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
31379 .numberOfConsumers = 1,
31380 .scale = 0.0f,
31381 .type = TestOperandType::TENSOR_FLOAT16,
31382 .zeroPoint = 0
31383 }, { // classesOut
31384 .channelQuant = {},
31385 .data = TestBuffer::createFromVector<int32_t>({}),
31386 .dimensions = {0},
31387 .isIgnored = false,
31388 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
31389 .numberOfConsumers = 0,
31390 .scale = 0.0f,
31391 .type = TestOperandType::TENSOR_INT32,
31392 .zeroPoint = 0
31393 }, { // batchSplitOut
31394 .channelQuant = {},
31395 .data = TestBuffer::createFromVector<int32_t>({}),
31396 .dimensions = {0},
31397 .isIgnored = false,
31398 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
31399 .numberOfConsumers = 1,
31400 .scale = 0.0f,
31401 .type = TestOperandType::TENSOR_INT32,
31402 .zeroPoint = 0
31403 }, { // in
31404 .channelQuant = {},
31405 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
31406 .dimensions = {1, 1, 1, 1},
31407 .isIgnored = false,
31408 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
31409 .numberOfConsumers = 1,
31410 .scale = 0.0f,
31411 .type = TestOperandType::TENSOR_FLOAT16,
31412 .zeroPoint = 0
31413 }, { // param11
31414 .channelQuant = {},
31415 .data = TestBuffer::createFromVector<int32_t>({2}),
31416 .dimensions = {},
31417 .isIgnored = false,
31418 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31419 .numberOfConsumers = 1,
31420 .scale = 0.0f,
31421 .type = TestOperandType::INT32,
31422 .zeroPoint = 0
31423 }, { // param12
31424 .channelQuant = {},
31425 .data = TestBuffer::createFromVector<int32_t>({2}),
31426 .dimensions = {},
31427 .isIgnored = false,
31428 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31429 .numberOfConsumers = 1,
31430 .scale = 0.0f,
31431 .type = TestOperandType::INT32,
31432 .zeroPoint = 0
31433 }, { // param13
31434 .channelQuant = {},
31435 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
31436 .dimensions = {},
31437 .isIgnored = false,
31438 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31439 .numberOfConsumers = 1,
31440 .scale = 0.0f,
31441 .type = TestOperandType::FLOAT16,
31442 .zeroPoint = 0
31443 }, { // param14
31444 .channelQuant = {},
31445 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
31446 .dimensions = {},
31447 .isIgnored = false,
31448 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31449 .numberOfConsumers = 1,
31450 .scale = 0.0f,
31451 .type = TestOperandType::FLOAT16,
31452 .zeroPoint = 0
31453 }, { // param15
31454 .channelQuant = {},
31455 .data = TestBuffer::createFromVector<int32_t>({4}),
31456 .dimensions = {},
31457 .isIgnored = false,
31458 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31459 .numberOfConsumers = 1,
31460 .scale = 0.0f,
31461 .type = TestOperandType::INT32,
31462 .zeroPoint = 0
31463 }, { // param16
31464 .channelQuant = {},
31465 .data = TestBuffer::createFromVector<int32_t>({4}),
31466 .dimensions = {},
31467 .isIgnored = false,
31468 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31469 .numberOfConsumers = 1,
31470 .scale = 0.0f,
31471 .type = TestOperandType::INT32,
31472 .zeroPoint = 0
31473 }, { // layout
31474 .channelQuant = {},
31475 .data = TestBuffer::createFromVector<bool8>({false}),
31476 .dimensions = {},
31477 .isIgnored = false,
31478 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31479 .numberOfConsumers = 1,
31480 .scale = 0.0f,
31481 .type = TestOperandType::BOOL,
31482 .zeroPoint = 0
31483 }, { // featureMap
31484 .channelQuant = {},
31485 .data = TestBuffer::createFromVector<_Float16>({}),
31486 .dimensions = {0, 2, 2, 1},
31487 .isIgnored = false,
31488 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
31489 .numberOfConsumers = 1,
31490 .scale = 0.0f,
31491 .type = TestOperandType::TENSOR_FLOAT16,
31492 .zeroPoint = 0
31493 }, { // param17
31494 .channelQuant = {},
31495 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
31496 .dimensions = {},
31497 .isIgnored = false,
31498 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
31499 .numberOfConsumers = 1,
31500 .scale = 0.0f,
31501 .type = TestOperandType::FLOAT16,
31502 .zeroPoint = 0
31503 }, { // out
31504 .channelQuant = {},
31505 .data = TestBuffer::createFromVector<_Float16>({}),
31506 .dimensions = {0, 2, 2, 1},
31507 .isIgnored = false,
31508 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
31509 .numberOfConsumers = 0,
31510 .scale = 0.0f,
31511 .type = TestOperandType::TENSOR_FLOAT16,
31512 .zeroPoint = 0
31513 }},
31514 .operations = {{
31515 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
31516 .outputs = {9, 10, 11, 12},
31517 .type = TestOperationType::BOX_WITH_NMS_LIMIT
31518 }, {
31519 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
31520 .outputs = {21},
31521 .type = TestOperationType::ROI_ALIGN
31522 }, {
31523 .inputs = {21, 22},
31524 .outputs = {23},
31525 .type = TestOperationType::SOFTMAX
31526 }},
31527 .outputIndexes = {9, 11, 23}
31528 },
31529 .minSupportedVersion = TestHalVersion::V1_2,
31530 .referenced = {}
31531 };
31532 return model;
31533 }
31534
31535 const auto dummy_test_model_zero_sized_float16 = TestModelManager::get().add("softmax_v1_2_zero_sized_float16", get_test_model_zero_sized_float16());
31536
31537 } // namespace generated_tests::softmax_v1_2
31538
31539