1 // clang-format off
2 // Generated file (from: tanh_v1_2.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4 OperandType type0(Type::TENSOR_FLOAT16, {1, 2, 2, 1});
5 // Phase 1, operands
6 auto input0 = model->addOperand(&type0);
7 auto output0 = model->addOperand(&type0);
8 // Phase 2, operations
9 model->addOperation(ANEURALNETWORKS_TANH, {input0}, {output0});
10 // Phase 3, inputs and outputs
11 model->identifyInputsAndOutputs(
12 {input0},
13 {output0});
14 assert(model->isValid());
15 }
16
is_ignored(int i)17 inline bool is_ignored(int i) {
18 static std::set<int> ignore = {};
19 return ignore.find(i) != ignore.end();
20 }
21
CreateModel_dynamic_output_shape(Model * model)22 void CreateModel_dynamic_output_shape(Model *model) {
23 OperandType type0(Type::TENSOR_FLOAT16, {1, 2, 2, 1});
24 OperandType type14(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
25 // Phase 1, operands
26 auto input0 = model->addOperand(&type0);
27 auto output0 = model->addOperand(&type14);
28 // Phase 2, operations
29 model->addOperation(ANEURALNETWORKS_TANH, {input0}, {output0});
30 // Phase 3, inputs and outputs
31 model->identifyInputsAndOutputs(
32 {input0},
33 {output0});
34 assert(model->isValid());
35 }
36
is_ignored_dynamic_output_shape(int i)37 inline bool is_ignored_dynamic_output_shape(int i) {
38 static std::set<int> ignore = {};
39 return ignore.find(i) != ignore.end();
40 }
41
CreateModel_2(Model * model)42 void CreateModel_2(Model *model) {
43 OperandType type1(Type::TENSOR_QUANT8_ASYMM, {256}, 0.05f, 100);
44 OperandType type2(Type::TENSOR_QUANT8_ASYMM, {256}, 0.0078125f, 128);
45 // Phase 1, operands
46 auto input01 = model->addOperand(&type1);
47 auto output01 = model->addOperand(&type2);
48 // Phase 2, operations
49 model->addOperation(ANEURALNETWORKS_TANH, {input01}, {output01});
50 // Phase 3, inputs and outputs
51 model->identifyInputsAndOutputs(
52 {input01},
53 {output01});
54 assert(model->isValid());
55 }
56
is_ignored_2(int i)57 inline bool is_ignored_2(int i) {
58 static std::set<int> ignore = {};
59 return ignore.find(i) != ignore.end();
60 }
61
CreateModel_dynamic_output_shape_2(Model * model)62 void CreateModel_dynamic_output_shape_2(Model *model) {
63 OperandType type1(Type::TENSOR_QUANT8_ASYMM, {256}, 0.05f, 100);
64 OperandType type15(Type::TENSOR_QUANT8_ASYMM, {0}, 0.0078125f, 128);
65 // Phase 1, operands
66 auto input01 = model->addOperand(&type1);
67 auto output01 = model->addOperand(&type15);
68 // Phase 2, operations
69 model->addOperation(ANEURALNETWORKS_TANH, {input01}, {output01});
70 // Phase 3, inputs and outputs
71 model->identifyInputsAndOutputs(
72 {input01},
73 {output01});
74 assert(model->isValid());
75 }
76
is_ignored_dynamic_output_shape_2(int i)77 inline bool is_ignored_dynamic_output_shape_2(int i) {
78 static std::set<int> ignore = {};
79 return ignore.find(i) != ignore.end();
80 }
81
CreateModel_zero_sized(Model * model)82 void CreateModel_zero_sized(Model *model) {
83 OperandType type10(Type::INT32, {});
84 OperandType type11(Type::BOOL, {});
85 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
86 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
87 OperandType type3(Type::TENSOR_FLOAT32, {1, 2});
88 OperandType type4(Type::TENSOR_FLOAT32, {1, 8});
89 OperandType type5(Type::TENSOR_FLOAT32, {0});
90 OperandType type6(Type::TENSOR_INT32, {0});
91 OperandType type7(Type::TENSOR_FLOAT32, {0, 4});
92 OperandType type8(Type::TENSOR_INT32, {1});
93 OperandType type9(Type::FLOAT32, {});
94 // Phase 1, operands
95 auto scores = model->addOperand(&type3);
96 auto roi = model->addOperand(&type4);
97 auto param = model->addOperand(&type8);
98 auto param1 = model->addOperand(&type9);
99 auto param2 = model->addOperand(&type10);
100 auto param3 = model->addOperand(&type10);
101 auto param4 = model->addOperand(&type9);
102 auto param5 = model->addOperand(&type9);
103 auto param6 = model->addOperand(&type9);
104 auto scoresOut = model->addOperand(&type5);
105 auto roiOut = model->addOperand(&type7);
106 auto classesOut = model->addOperand(&type6);
107 auto batchSplitOut = model->addOperand(&type6);
108 auto in = model->addOperand(&type12);
109 auto param7 = model->addOperand(&type10);
110 auto param8 = model->addOperand(&type10);
111 auto param9 = model->addOperand(&type9);
112 auto param10 = model->addOperand(&type9);
113 auto param11 = model->addOperand(&type10);
114 auto param12 = model->addOperand(&type10);
115 auto layout = model->addOperand(&type11);
116 auto featureMap = model->addOperand(&type13);
117 auto out = model->addOperand(&type13);
118 // Phase 2, operations
119 static float scores_init[] = {0.9f, 0.1f};
120 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
121 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
122 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
123 static int32_t param_init[] = {0};
124 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
125 static float param1_init[] = {0.3f};
126 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
127 static int32_t param2_init[] = {-1};
128 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
129 static int32_t param3_init[] = {0};
130 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
131 static float param4_init[] = {0.4f};
132 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
133 static float param5_init[] = {1.0f};
134 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
135 static float param6_init[] = {0.3f};
136 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
137 static int32_t param7_init[] = {2};
138 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
139 static int32_t param8_init[] = {2};
140 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
141 static float param9_init[] = {2.0f};
142 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
143 static float param10_init[] = {2.0f};
144 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
145 static int32_t param11_init[] = {4};
146 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
147 static int32_t param12_init[] = {4};
148 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
149 static bool8 layout_init[] = {false};
150 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
151 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
152 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
153 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
154 // Phase 3, inputs and outputs
155 model->identifyInputsAndOutputs(
156 {in},
157 {scoresOut, classesOut, out});
158 assert(model->isValid());
159 }
160
is_ignored_zero_sized(int i)161 inline bool is_ignored_zero_sized(int i) {
162 static std::set<int> ignore = {};
163 return ignore.find(i) != ignore.end();
164 }
165
CreateModel_zero_sized_relaxed(Model * model)166 void CreateModel_zero_sized_relaxed(Model *model) {
167 OperandType type10(Type::INT32, {});
168 OperandType type11(Type::BOOL, {});
169 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
170 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
171 OperandType type3(Type::TENSOR_FLOAT32, {1, 2});
172 OperandType type4(Type::TENSOR_FLOAT32, {1, 8});
173 OperandType type5(Type::TENSOR_FLOAT32, {0});
174 OperandType type6(Type::TENSOR_INT32, {0});
175 OperandType type7(Type::TENSOR_FLOAT32, {0, 4});
176 OperandType type8(Type::TENSOR_INT32, {1});
177 OperandType type9(Type::FLOAT32, {});
178 // Phase 1, operands
179 auto scores = model->addOperand(&type3);
180 auto roi = model->addOperand(&type4);
181 auto param = model->addOperand(&type8);
182 auto param1 = model->addOperand(&type9);
183 auto param2 = model->addOperand(&type10);
184 auto param3 = model->addOperand(&type10);
185 auto param4 = model->addOperand(&type9);
186 auto param5 = model->addOperand(&type9);
187 auto param6 = model->addOperand(&type9);
188 auto scoresOut = model->addOperand(&type5);
189 auto roiOut = model->addOperand(&type7);
190 auto classesOut = model->addOperand(&type6);
191 auto batchSplitOut = model->addOperand(&type6);
192 auto in = model->addOperand(&type12);
193 auto param7 = model->addOperand(&type10);
194 auto param8 = model->addOperand(&type10);
195 auto param9 = model->addOperand(&type9);
196 auto param10 = model->addOperand(&type9);
197 auto param11 = model->addOperand(&type10);
198 auto param12 = model->addOperand(&type10);
199 auto layout = model->addOperand(&type11);
200 auto featureMap = model->addOperand(&type13);
201 auto out = model->addOperand(&type13);
202 // Phase 2, operations
203 static float scores_init[] = {0.9f, 0.1f};
204 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
205 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
206 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
207 static int32_t param_init[] = {0};
208 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
209 static float param1_init[] = {0.3f};
210 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
211 static int32_t param2_init[] = {-1};
212 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
213 static int32_t param3_init[] = {0};
214 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
215 static float param4_init[] = {0.4f};
216 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
217 static float param5_init[] = {1.0f};
218 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
219 static float param6_init[] = {0.3f};
220 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
221 static int32_t param7_init[] = {2};
222 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
223 static int32_t param8_init[] = {2};
224 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
225 static float param9_init[] = {2.0f};
226 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
227 static float param10_init[] = {2.0f};
228 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
229 static int32_t param11_init[] = {4};
230 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
231 static int32_t param12_init[] = {4};
232 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
233 static bool8 layout_init[] = {false};
234 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
235 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
236 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
237 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
238 // Phase 3, inputs and outputs
239 model->identifyInputsAndOutputs(
240 {in},
241 {scoresOut, classesOut, out});
242 // Phase 4: set relaxed execution
243 model->relaxComputationFloat32toFloat16(true);
244 assert(model->isValid());
245 }
246
is_ignored_zero_sized_relaxed(int i)247 inline bool is_ignored_zero_sized_relaxed(int i) {
248 static std::set<int> ignore = {};
249 return ignore.find(i) != ignore.end();
250 }
251
CreateModel_zero_sized_quant8(Model * model)252 void CreateModel_zero_sized_quant8(Model *model) {
253 OperandType type10(Type::INT32, {});
254 OperandType type11(Type::BOOL, {});
255 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
256 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
257 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.0078125f, 128);
258 OperandType type19(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
259 OperandType type20(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
260 OperandType type21(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
261 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
262 OperandType type6(Type::TENSOR_INT32, {0});
263 OperandType type8(Type::TENSOR_INT32, {1});
264 OperandType type9(Type::FLOAT32, {});
265 // Phase 1, operands
266 auto scores = model->addOperand(&type21);
267 auto roi = model->addOperand(&type19);
268 auto param = model->addOperand(&type8);
269 auto param1 = model->addOperand(&type9);
270 auto param2 = model->addOperand(&type10);
271 auto param3 = model->addOperand(&type10);
272 auto param4 = model->addOperand(&type9);
273 auto param5 = model->addOperand(&type9);
274 auto param6 = model->addOperand(&type9);
275 auto scoresOut = model->addOperand(&type22);
276 auto roiOut = model->addOperand(&type20);
277 auto classesOut = model->addOperand(&type6);
278 auto batchSplitOut = model->addOperand(&type6);
279 auto in = model->addOperand(&type17);
280 auto param7 = model->addOperand(&type10);
281 auto param8 = model->addOperand(&type10);
282 auto param9 = model->addOperand(&type9);
283 auto param10 = model->addOperand(&type9);
284 auto param11 = model->addOperand(&type10);
285 auto param12 = model->addOperand(&type10);
286 auto layout = model->addOperand(&type11);
287 auto featureMap = model->addOperand(&type16);
288 auto out = model->addOperand(&type18);
289 // Phase 2, operations
290 static uint8_t scores_init[] = {137, 129};
291 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
292 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
293 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
294 static int32_t param_init[] = {0};
295 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
296 static float param1_init[] = {0.3f};
297 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
298 static int32_t param2_init[] = {-1};
299 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
300 static int32_t param3_init[] = {0};
301 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
302 static float param4_init[] = {0.4f};
303 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
304 static float param5_init[] = {1.0f};
305 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
306 static float param6_init[] = {0.3f};
307 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
308 static int32_t param7_init[] = {2};
309 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
310 static int32_t param8_init[] = {2};
311 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
312 static float param9_init[] = {2.0f};
313 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
314 static float param10_init[] = {2.0f};
315 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
316 static int32_t param11_init[] = {4};
317 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
318 static int32_t param12_init[] = {4};
319 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
320 static bool8 layout_init[] = {false};
321 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
322 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
323 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
324 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
325 // Phase 3, inputs and outputs
326 model->identifyInputsAndOutputs(
327 {in},
328 {scoresOut, classesOut, out});
329 assert(model->isValid());
330 }
331
is_ignored_zero_sized_quant8(int i)332 inline bool is_ignored_zero_sized_quant8(int i) {
333 static std::set<int> ignore = {};
334 return ignore.find(i) != ignore.end();
335 }
336
CreateModel_zero_sized_float16(Model * model)337 void CreateModel_zero_sized_float16(Model *model) {
338 OperandType type10(Type::INT32, {});
339 OperandType type11(Type::BOOL, {});
340 OperandType type23(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
341 OperandType type24(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
342 OperandType type25(Type::FLOAT16, {});
343 OperandType type26(Type::TENSOR_FLOAT16, {1, 8});
344 OperandType type27(Type::TENSOR_FLOAT16, {0, 4});
345 OperandType type28(Type::TENSOR_FLOAT16, {1, 2});
346 OperandType type29(Type::TENSOR_FLOAT16, {0});
347 OperandType type6(Type::TENSOR_INT32, {0});
348 OperandType type8(Type::TENSOR_INT32, {1});
349 // Phase 1, operands
350 auto scores = model->addOperand(&type28);
351 auto roi = model->addOperand(&type26);
352 auto param = model->addOperand(&type8);
353 auto param1 = model->addOperand(&type25);
354 auto param2 = model->addOperand(&type10);
355 auto param3 = model->addOperand(&type10);
356 auto param4 = model->addOperand(&type25);
357 auto param5 = model->addOperand(&type25);
358 auto param6 = model->addOperand(&type25);
359 auto scoresOut = model->addOperand(&type29);
360 auto roiOut = model->addOperand(&type27);
361 auto classesOut = model->addOperand(&type6);
362 auto batchSplitOut = model->addOperand(&type6);
363 auto in = model->addOperand(&type24);
364 auto param7 = model->addOperand(&type10);
365 auto param8 = model->addOperand(&type10);
366 auto param9 = model->addOperand(&type25);
367 auto param10 = model->addOperand(&type25);
368 auto param11 = model->addOperand(&type10);
369 auto param12 = model->addOperand(&type10);
370 auto layout = model->addOperand(&type11);
371 auto featureMap = model->addOperand(&type23);
372 auto out = model->addOperand(&type23);
373 // Phase 2, operations
374 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
375 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
376 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
377 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
378 static int32_t param_init[] = {0};
379 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
380 static _Float16 param1_init[] = {0.30000001192092896f};
381 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
382 static int32_t param2_init[] = {-1};
383 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
384 static int32_t param3_init[] = {0};
385 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
386 static _Float16 param4_init[] = {0.4000000059604645f};
387 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
388 static _Float16 param5_init[] = {1.0f};
389 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
390 static _Float16 param6_init[] = {0.30000001192092896f};
391 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
392 static int32_t param7_init[] = {2};
393 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
394 static int32_t param8_init[] = {2};
395 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
396 static _Float16 param9_init[] = {2.0f};
397 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
398 static _Float16 param10_init[] = {2.0f};
399 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
400 static int32_t param11_init[] = {4};
401 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
402 static int32_t param12_init[] = {4};
403 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
404 static bool8 layout_init[] = {false};
405 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
406 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
407 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
408 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
409 // Phase 3, inputs and outputs
410 model->identifyInputsAndOutputs(
411 {in},
412 {scoresOut, classesOut, out});
413 assert(model->isValid());
414 }
415
is_ignored_zero_sized_float16(int i)416 inline bool is_ignored_zero_sized_float16(int i) {
417 static std::set<int> ignore = {};
418 return ignore.find(i) != ignore.end();
419 }
420
CreateModel_zero_sized_dynamic_output_shape(Model * model)421 void CreateModel_zero_sized_dynamic_output_shape(Model *model) {
422 OperandType type10(Type::INT32, {});
423 OperandType type11(Type::BOOL, {});
424 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
425 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
426 OperandType type3(Type::TENSOR_FLOAT32, {1, 2});
427 OperandType type30(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
428 OperandType type4(Type::TENSOR_FLOAT32, {1, 8});
429 OperandType type5(Type::TENSOR_FLOAT32, {0});
430 OperandType type6(Type::TENSOR_INT32, {0});
431 OperandType type7(Type::TENSOR_FLOAT32, {0, 4});
432 OperandType type8(Type::TENSOR_INT32, {1});
433 OperandType type9(Type::FLOAT32, {});
434 // Phase 1, operands
435 auto scores = model->addOperand(&type3);
436 auto roi = model->addOperand(&type4);
437 auto param = model->addOperand(&type8);
438 auto param1 = model->addOperand(&type9);
439 auto param2 = model->addOperand(&type10);
440 auto param3 = model->addOperand(&type10);
441 auto param4 = model->addOperand(&type9);
442 auto param5 = model->addOperand(&type9);
443 auto param6 = model->addOperand(&type9);
444 auto scoresOut = model->addOperand(&type5);
445 auto roiOut = model->addOperand(&type7);
446 auto classesOut = model->addOperand(&type6);
447 auto batchSplitOut = model->addOperand(&type6);
448 auto in = model->addOperand(&type12);
449 auto param7 = model->addOperand(&type10);
450 auto param8 = model->addOperand(&type10);
451 auto param9 = model->addOperand(&type9);
452 auto param10 = model->addOperand(&type9);
453 auto param11 = model->addOperand(&type10);
454 auto param12 = model->addOperand(&type10);
455 auto layout = model->addOperand(&type11);
456 auto featureMap = model->addOperand(&type13);
457 auto out = model->addOperand(&type30);
458 // Phase 2, operations
459 static float scores_init[] = {0.9f, 0.1f};
460 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
461 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
462 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
463 static int32_t param_init[] = {0};
464 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
465 static float param1_init[] = {0.3f};
466 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
467 static int32_t param2_init[] = {-1};
468 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
469 static int32_t param3_init[] = {0};
470 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
471 static float param4_init[] = {0.4f};
472 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
473 static float param5_init[] = {1.0f};
474 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
475 static float param6_init[] = {0.3f};
476 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
477 static int32_t param7_init[] = {2};
478 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
479 static int32_t param8_init[] = {2};
480 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
481 static float param9_init[] = {2.0f};
482 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
483 static float param10_init[] = {2.0f};
484 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
485 static int32_t param11_init[] = {4};
486 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
487 static int32_t param12_init[] = {4};
488 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
489 static bool8 layout_init[] = {false};
490 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
491 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
492 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
493 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
494 // Phase 3, inputs and outputs
495 model->identifyInputsAndOutputs(
496 {in},
497 {scoresOut, classesOut, out});
498 assert(model->isValid());
499 }
500
is_ignored_zero_sized_dynamic_output_shape(int i)501 inline bool is_ignored_zero_sized_dynamic_output_shape(int i) {
502 static std::set<int> ignore = {};
503 return ignore.find(i) != ignore.end();
504 }
505
CreateModel_zero_sized_dynamic_output_shape_relaxed(Model * model)506 void CreateModel_zero_sized_dynamic_output_shape_relaxed(Model *model) {
507 OperandType type10(Type::INT32, {});
508 OperandType type11(Type::BOOL, {});
509 OperandType type12(Type::TENSOR_FLOAT32, {1, 1, 1, 1});
510 OperandType type13(Type::TENSOR_FLOAT32, {0, 2, 2, 1});
511 OperandType type3(Type::TENSOR_FLOAT32, {1, 2});
512 OperandType type30(Type::TENSOR_FLOAT32, {0, 0, 0, 0});
513 OperandType type4(Type::TENSOR_FLOAT32, {1, 8});
514 OperandType type5(Type::TENSOR_FLOAT32, {0});
515 OperandType type6(Type::TENSOR_INT32, {0});
516 OperandType type7(Type::TENSOR_FLOAT32, {0, 4});
517 OperandType type8(Type::TENSOR_INT32, {1});
518 OperandType type9(Type::FLOAT32, {});
519 // Phase 1, operands
520 auto scores = model->addOperand(&type3);
521 auto roi = model->addOperand(&type4);
522 auto param = model->addOperand(&type8);
523 auto param1 = model->addOperand(&type9);
524 auto param2 = model->addOperand(&type10);
525 auto param3 = model->addOperand(&type10);
526 auto param4 = model->addOperand(&type9);
527 auto param5 = model->addOperand(&type9);
528 auto param6 = model->addOperand(&type9);
529 auto scoresOut = model->addOperand(&type5);
530 auto roiOut = model->addOperand(&type7);
531 auto classesOut = model->addOperand(&type6);
532 auto batchSplitOut = model->addOperand(&type6);
533 auto in = model->addOperand(&type12);
534 auto param7 = model->addOperand(&type10);
535 auto param8 = model->addOperand(&type10);
536 auto param9 = model->addOperand(&type9);
537 auto param10 = model->addOperand(&type9);
538 auto param11 = model->addOperand(&type10);
539 auto param12 = model->addOperand(&type10);
540 auto layout = model->addOperand(&type11);
541 auto featureMap = model->addOperand(&type13);
542 auto out = model->addOperand(&type30);
543 // Phase 2, operations
544 static float scores_init[] = {0.9f, 0.1f};
545 model->setOperandValue(scores, scores_init, sizeof(float) * 2);
546 static float roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
547 model->setOperandValue(roi, roi_init, sizeof(float) * 8);
548 static int32_t param_init[] = {0};
549 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
550 static float param1_init[] = {0.3f};
551 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
552 static int32_t param2_init[] = {-1};
553 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
554 static int32_t param3_init[] = {0};
555 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
556 static float param4_init[] = {0.4f};
557 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
558 static float param5_init[] = {1.0f};
559 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
560 static float param6_init[] = {0.3f};
561 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
562 static int32_t param7_init[] = {2};
563 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
564 static int32_t param8_init[] = {2};
565 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
566 static float param9_init[] = {2.0f};
567 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
568 static float param10_init[] = {2.0f};
569 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
570 static int32_t param11_init[] = {4};
571 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
572 static int32_t param12_init[] = {4};
573 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
574 static bool8 layout_init[] = {false};
575 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
576 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
577 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
578 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
579 // Phase 3, inputs and outputs
580 model->identifyInputsAndOutputs(
581 {in},
582 {scoresOut, classesOut, out});
583 // Phase 4: set relaxed execution
584 model->relaxComputationFloat32toFloat16(true);
585 assert(model->isValid());
586 }
587
is_ignored_zero_sized_dynamic_output_shape_relaxed(int i)588 inline bool is_ignored_zero_sized_dynamic_output_shape_relaxed(int i) {
589 static std::set<int> ignore = {};
590 return ignore.find(i) != ignore.end();
591 }
592
CreateModel_zero_sized_dynamic_output_shape_quant8(Model * model)593 void CreateModel_zero_sized_dynamic_output_shape_quant8(Model *model) {
594 OperandType type10(Type::INT32, {});
595 OperandType type11(Type::BOOL, {});
596 OperandType type16(Type::TENSOR_QUANT8_ASYMM, {0, 2, 2, 1}, 0.1f, 128);
597 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {1, 1, 1, 1}, 0.1f, 128);
598 OperandType type19(Type::TENSOR_QUANT16_ASYMM, {1, 8}, 0.125f, 0);
599 OperandType type20(Type::TENSOR_QUANT16_ASYMM, {0, 4}, 0.125f, 0);
600 OperandType type21(Type::TENSOR_QUANT8_ASYMM, {1, 2}, 0.1f, 128);
601 OperandType type22(Type::TENSOR_QUANT8_ASYMM, {0}, 0.1f, 128);
602 OperandType type31(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0}, 0.0078125f, 128);
603 OperandType type6(Type::TENSOR_INT32, {0});
604 OperandType type8(Type::TENSOR_INT32, {1});
605 OperandType type9(Type::FLOAT32, {});
606 // Phase 1, operands
607 auto scores = model->addOperand(&type21);
608 auto roi = model->addOperand(&type19);
609 auto param = model->addOperand(&type8);
610 auto param1 = model->addOperand(&type9);
611 auto param2 = model->addOperand(&type10);
612 auto param3 = model->addOperand(&type10);
613 auto param4 = model->addOperand(&type9);
614 auto param5 = model->addOperand(&type9);
615 auto param6 = model->addOperand(&type9);
616 auto scoresOut = model->addOperand(&type22);
617 auto roiOut = model->addOperand(&type20);
618 auto classesOut = model->addOperand(&type6);
619 auto batchSplitOut = model->addOperand(&type6);
620 auto in = model->addOperand(&type17);
621 auto param7 = model->addOperand(&type10);
622 auto param8 = model->addOperand(&type10);
623 auto param9 = model->addOperand(&type9);
624 auto param10 = model->addOperand(&type9);
625 auto param11 = model->addOperand(&type10);
626 auto param12 = model->addOperand(&type10);
627 auto layout = model->addOperand(&type11);
628 auto featureMap = model->addOperand(&type16);
629 auto out = model->addOperand(&type31);
630 // Phase 2, operations
631 static uint8_t scores_init[] = {137, 129};
632 model->setOperandValue(scores, scores_init, sizeof(uint8_t) * 2);
633 static uint16_t roi_init[] = {8, 8, 80, 80, 0, 0, 80, 80};
634 model->setOperandValue(roi, roi_init, sizeof(uint16_t) * 8);
635 static int32_t param_init[] = {0};
636 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
637 static float param1_init[] = {0.3f};
638 model->setOperandValue(param1, param1_init, sizeof(float) * 1);
639 static int32_t param2_init[] = {-1};
640 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
641 static int32_t param3_init[] = {0};
642 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
643 static float param4_init[] = {0.4f};
644 model->setOperandValue(param4, param4_init, sizeof(float) * 1);
645 static float param5_init[] = {1.0f};
646 model->setOperandValue(param5, param5_init, sizeof(float) * 1);
647 static float param6_init[] = {0.3f};
648 model->setOperandValue(param6, param6_init, sizeof(float) * 1);
649 static int32_t param7_init[] = {2};
650 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
651 static int32_t param8_init[] = {2};
652 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
653 static float param9_init[] = {2.0f};
654 model->setOperandValue(param9, param9_init, sizeof(float) * 1);
655 static float param10_init[] = {2.0f};
656 model->setOperandValue(param10, param10_init, sizeof(float) * 1);
657 static int32_t param11_init[] = {4};
658 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
659 static int32_t param12_init[] = {4};
660 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
661 static bool8 layout_init[] = {false};
662 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
663 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
664 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
665 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
666 // Phase 3, inputs and outputs
667 model->identifyInputsAndOutputs(
668 {in},
669 {scoresOut, classesOut, out});
670 assert(model->isValid());
671 }
672
is_ignored_zero_sized_dynamic_output_shape_quant8(int i)673 inline bool is_ignored_zero_sized_dynamic_output_shape_quant8(int i) {
674 static std::set<int> ignore = {};
675 return ignore.find(i) != ignore.end();
676 }
677
CreateModel_zero_sized_dynamic_output_shape_float16(Model * model)678 void CreateModel_zero_sized_dynamic_output_shape_float16(Model *model) {
679 OperandType type10(Type::INT32, {});
680 OperandType type11(Type::BOOL, {});
681 OperandType type14(Type::TENSOR_FLOAT16, {0, 0, 0, 0});
682 OperandType type23(Type::TENSOR_FLOAT16, {0, 2, 2, 1});
683 OperandType type24(Type::TENSOR_FLOAT16, {1, 1, 1, 1});
684 OperandType type25(Type::FLOAT16, {});
685 OperandType type26(Type::TENSOR_FLOAT16, {1, 8});
686 OperandType type27(Type::TENSOR_FLOAT16, {0, 4});
687 OperandType type28(Type::TENSOR_FLOAT16, {1, 2});
688 OperandType type32(Type::TENSOR_FLOAT16, {0});
689 OperandType type6(Type::TENSOR_INT32, {0});
690 OperandType type8(Type::TENSOR_INT32, {1});
691 // Phase 1, operands
692 auto scores = model->addOperand(&type28);
693 auto roi = model->addOperand(&type26);
694 auto param = model->addOperand(&type8);
695 auto param1 = model->addOperand(&type25);
696 auto param2 = model->addOperand(&type10);
697 auto param3 = model->addOperand(&type10);
698 auto param4 = model->addOperand(&type25);
699 auto param5 = model->addOperand(&type25);
700 auto param6 = model->addOperand(&type25);
701 auto scoresOut = model->addOperand(&type32);
702 auto roiOut = model->addOperand(&type27);
703 auto classesOut = model->addOperand(&type6);
704 auto batchSplitOut = model->addOperand(&type6);
705 auto in = model->addOperand(&type24);
706 auto param7 = model->addOperand(&type10);
707 auto param8 = model->addOperand(&type10);
708 auto param9 = model->addOperand(&type25);
709 auto param10 = model->addOperand(&type25);
710 auto param11 = model->addOperand(&type10);
711 auto param12 = model->addOperand(&type10);
712 auto layout = model->addOperand(&type11);
713 auto featureMap = model->addOperand(&type23);
714 auto out = model->addOperand(&type14);
715 // Phase 2, operations
716 static _Float16 scores_init[] = {0.8999999761581421f, 0.10000000149011612f};
717 model->setOperandValue(scores, scores_init, sizeof(_Float16) * 2);
718 static _Float16 roi_init[] = {1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f};
719 model->setOperandValue(roi, roi_init, sizeof(_Float16) * 8);
720 static int32_t param_init[] = {0};
721 model->setOperandValue(param, param_init, sizeof(int32_t) * 1);
722 static _Float16 param1_init[] = {0.30000001192092896f};
723 model->setOperandValue(param1, param1_init, sizeof(_Float16) * 1);
724 static int32_t param2_init[] = {-1};
725 model->setOperandValue(param2, param2_init, sizeof(int32_t) * 1);
726 static int32_t param3_init[] = {0};
727 model->setOperandValue(param3, param3_init, sizeof(int32_t) * 1);
728 static _Float16 param4_init[] = {0.4000000059604645f};
729 model->setOperandValue(param4, param4_init, sizeof(_Float16) * 1);
730 static _Float16 param5_init[] = {1.0f};
731 model->setOperandValue(param5, param5_init, sizeof(_Float16) * 1);
732 static _Float16 param6_init[] = {0.30000001192092896f};
733 model->setOperandValue(param6, param6_init, sizeof(_Float16) * 1);
734 static int32_t param7_init[] = {2};
735 model->setOperandValue(param7, param7_init, sizeof(int32_t) * 1);
736 static int32_t param8_init[] = {2};
737 model->setOperandValue(param8, param8_init, sizeof(int32_t) * 1);
738 static _Float16 param9_init[] = {2.0f};
739 model->setOperandValue(param9, param9_init, sizeof(_Float16) * 1);
740 static _Float16 param10_init[] = {2.0f};
741 model->setOperandValue(param10, param10_init, sizeof(_Float16) * 1);
742 static int32_t param11_init[] = {4};
743 model->setOperandValue(param11, param11_init, sizeof(int32_t) * 1);
744 static int32_t param12_init[] = {4};
745 model->setOperandValue(param12, param12_init, sizeof(int32_t) * 1);
746 static bool8 layout_init[] = {false};
747 model->setOperandValue(layout, layout_init, sizeof(bool8) * 1);
748 model->addOperation(ANEURALNETWORKS_BOX_WITH_NMS_LIMIT, {scores, roi, param, param1, param2, param3, param4, param5, param6}, {scoresOut, roiOut, classesOut, batchSplitOut});
749 model->addOperation(ANEURALNETWORKS_ROI_ALIGN, {in, roiOut, batchSplitOut, param7, param8, param9, param10, param11, param12, layout}, {featureMap});
750 model->addOperation(ANEURALNETWORKS_TANH, {featureMap}, {out});
751 // Phase 3, inputs and outputs
752 model->identifyInputsAndOutputs(
753 {in},
754 {scoresOut, classesOut, out});
755 assert(model->isValid());
756 }
757
is_ignored_zero_sized_dynamic_output_shape_float16(int i)758 inline bool is_ignored_zero_sized_dynamic_output_shape_float16(int i) {
759 static std::set<int> ignore = {};
760 return ignore.find(i) != ignore.end();
761 }
762
763