1 // Copyright 2020 Google LLC
2 //
3 // This source code is licensed under the BSD-style license found in the
4 // LICENSE file in the root directory of this source tree.
5
6 #include <xnnpack.h>
7
8 #include <array>
9 #include <algorithm>
10 #include <functional>
11 #include <iostream>
12 #include <limits>
13 #include <random>
14
15 #include <fp16/fp16.h>
16
17 #include "models/models.h"
18
19 namespace models {
20
FP16MobileNetV3Large(pthreadpool_t threadpool)21 ExecutionPlan FP16MobileNetV3Large(pthreadpool_t threadpool) {
22 alignas(16) static std::array<uint16_t, 150528> v0;
23 alignas(16) static std::array<uint16_t, 200704> v1;
24 alignas(16) static std::array<uint16_t, 200704> v2;
25 alignas(16) static std::array<uint16_t, 200704> v3;
26 alignas(16) static std::array<uint16_t, 200704> v4;
27 alignas(16) static std::array<uint16_t, 200704> v5;
28 alignas(16) static std::array<uint16_t, 802816> v6;
29 alignas(16) static std::array<uint16_t, 200704> v7;
30 alignas(16) static std::array<uint16_t, 75264> v8;
31 alignas(16) static std::array<uint16_t, 225792> v9;
32 alignas(16) static std::array<uint16_t, 225792> v10;
33 alignas(16) static std::array<uint16_t, 75264> v11;
34 alignas(16) static std::array<uint16_t, 75264> v12;
35 alignas(16) static std::array<uint16_t, 225792> v13;
36 alignas(16) static std::array<uint16_t, 56448> v14;
37 alignas(16) static std::array<uint16_t, 72> v15;
38 alignas(16) static std::array<uint16_t, 24> v16;
39 alignas(16) static std::array<uint16_t, 72> v17;
40 alignas(16) static std::array<uint16_t, 56448> v18;
41 alignas(16) static std::array<uint16_t, 31360> v19;
42 alignas(16) static std::array<uint16_t, 94080> v20;
43 alignas(16) static std::array<uint16_t, 94080> v21;
44 alignas(16) static std::array<uint16_t, 120> v22;
45 alignas(16) static std::array<uint16_t, 32> v23;
46 alignas(16) static std::array<uint16_t, 120> v24;
47 alignas(16) static std::array<uint16_t, 94080> v25;
48 alignas(16) static std::array<uint16_t, 31360> v26;
49 alignas(16) static std::array<uint16_t, 31360> v27;
50 alignas(16) static std::array<uint16_t, 94080> v28;
51 alignas(16) static std::array<uint16_t, 94080> v29;
52 alignas(16) static std::array<uint16_t, 120> v30;
53 alignas(16) static std::array<uint16_t, 32> v31;
54 alignas(16) static std::array<uint16_t, 120> v32;
55 alignas(16) static std::array<uint16_t, 94080> v33;
56 alignas(16) static std::array<uint16_t, 31360> v34;
57 alignas(16) static std::array<uint16_t, 31360> v35;
58 alignas(16) static std::array<uint16_t, 188160> v36;
59 alignas(16) static std::array<uint16_t, 188160> v37;
60 alignas(16) static std::array<uint16_t, 47040> v38;
61 alignas(16) static std::array<uint16_t, 47040> v39;
62 alignas(16) static std::array<uint16_t, 15680> v40;
63 alignas(16) static std::array<uint16_t, 39200> v41;
64 alignas(16) static std::array<uint16_t, 39200> v42;
65 alignas(16) static std::array<uint16_t, 39200> v43;
66 alignas(16) static std::array<uint16_t, 39200> v44;
67 alignas(16) static std::array<uint16_t, 15680> v45;
68 alignas(16) static std::array<uint16_t, 15680> v46;
69 alignas(16) static std::array<uint16_t, 36064> v47;
70 alignas(16) static std::array<uint16_t, 36064> v48;
71 alignas(16) static std::array<uint16_t, 36064> v49;
72 alignas(16) static std::array<uint16_t, 36064> v50;
73 alignas(16) static std::array<uint16_t, 15680> v51;
74 alignas(16) static std::array<uint16_t, 15680> v52;
75 alignas(16) static std::array<uint16_t, 36064> v53;
76 alignas(16) static std::array<uint16_t, 36064> v54;
77 alignas(16) static std::array<uint16_t, 36064> v55;
78 alignas(16) static std::array<uint16_t, 36064> v56;
79 alignas(16) static std::array<uint16_t, 15680> v57;
80 alignas(16) static std::array<uint16_t, 15680> v58;
81 alignas(16) static std::array<uint16_t, 94080> v59;
82 alignas(16) static std::array<uint16_t, 94080> v60;
83 alignas(16) static std::array<uint16_t, 94080> v61;
84 alignas(16) static std::array<uint16_t, 94080> v62;
85 alignas(16) static std::array<uint16_t, 480> v63;
86 alignas(16) static std::array<uint16_t, 120> v64;
87 alignas(16) static std::array<uint16_t, 480> v65;
88 alignas(16) static std::array<uint16_t, 94080> v66;
89 alignas(16) static std::array<uint16_t, 21952> v67;
90 alignas(16) static std::array<uint16_t, 131712> v68;
91 alignas(16) static std::array<uint16_t, 131712> v69;
92 alignas(16) static std::array<uint16_t, 131712> v70;
93 alignas(16) static std::array<uint16_t, 131712> v71;
94 alignas(16) static std::array<uint16_t, 672> v72;
95 alignas(16) static std::array<uint16_t, 168> v73;
96 alignas(16) static std::array<uint16_t, 672> v74;
97 alignas(16) static std::array<uint16_t, 131712> v75;
98 alignas(16) static std::array<uint16_t, 21952> v76;
99 alignas(16) static std::array<uint16_t, 21952> v77;
100 alignas(16) static std::array<uint16_t, 131712> v78;
101 alignas(16) static std::array<uint16_t, 131712> v79;
102 alignas(16) static std::array<uint16_t, 32928> v80;
103 alignas(16) static std::array<uint16_t, 32928> v81;
104 alignas(16) static std::array<uint16_t, 672> v82;
105 alignas(16) static std::array<uint16_t, 168> v83;
106 alignas(16) static std::array<uint16_t, 672> v84;
107 alignas(16) static std::array<uint16_t, 32928> v85;
108 alignas(16) static std::array<uint16_t, 7840> v86;
109 alignas(16) static std::array<uint16_t, 47040> v87;
110 alignas(16) static std::array<uint16_t, 47040> v88;
111 alignas(16) static std::array<uint16_t, 47040> v89;
112 alignas(16) static std::array<uint16_t, 47040> v90;
113 alignas(16) static std::array<uint16_t, 960> v91;
114 alignas(16) static std::array<uint16_t, 240> v92;
115 alignas(16) static std::array<uint16_t, 960> v93;
116 alignas(16) static std::array<uint16_t, 47040> v94;
117 alignas(16) static std::array<uint16_t, 7840> v95;
118 alignas(16) static std::array<uint16_t, 7840> v96;
119 alignas(16) static std::array<uint16_t, 47040> v97;
120 alignas(16) static std::array<uint16_t, 47040> v98;
121 alignas(16) static std::array<uint16_t, 47040> v99;
122 alignas(16) static std::array<uint16_t, 47040> v100;
123 alignas(16) static std::array<uint16_t, 960> v101;
124 alignas(16) static std::array<uint16_t, 240> v102;
125 alignas(16) static std::array<uint16_t, 960> v103;
126 alignas(16) static std::array<uint16_t, 47040> v104;
127 alignas(16) static std::array<uint16_t, 7840> v105;
128 alignas(16) static std::array<uint16_t, 7840> v106;
129 alignas(16) static std::array<uint16_t, 47040> v107;
130 alignas(16) static std::array<uint16_t, 47040> v108;
131 alignas(16) static std::array<uint16_t, 960> v109;
132 alignas(16) static std::array<uint16_t, 1280> v110;
133 alignas(16) static std::array<uint16_t, 1280> v111;
134 alignas(16) static std::array<uint16_t, 1280> v112;
135 alignas(16) static std::array<uint16_t, 1001> v113;
136 alignas(16) static std::array<uint16_t, 432> w114;
137 alignas(16) static std::array<uint16_t, 16> w115;
138 alignas(16) static std::array<uint16_t, 144> w116;
139 alignas(16) static std::array<uint16_t, 16> w117;
140 alignas(16) static std::array<uint16_t, 256> w118;
141 alignas(16) static std::array<uint16_t, 16> w119;
142 alignas(16) static std::array<uint16_t, 1024> w120;
143 alignas(16) static std::array<uint16_t, 64> w121;
144 alignas(16) static std::array<uint16_t, 576> w122;
145 alignas(16) static std::array<uint16_t, 64> w123;
146 alignas(16) static std::array<uint16_t, 1536> w124;
147 alignas(16) static std::array<uint16_t, 24> w125;
148 alignas(16) static std::array<uint16_t, 1728> w126;
149 alignas(16) static std::array<uint16_t, 72> w127;
150 alignas(16) static std::array<uint16_t, 648> w128;
151 alignas(16) static std::array<uint16_t, 72> w129;
152 alignas(16) static std::array<uint16_t, 1728> w130;
153 alignas(16) static std::array<uint16_t, 24> w131;
154 alignas(16) static std::array<uint16_t, 1728> w132;
155 alignas(16) static std::array<uint16_t, 72> w133;
156 alignas(16) static std::array<uint16_t, 1800> w134;
157 alignas(16) static std::array<uint16_t, 72> w135;
158 alignas(16) static std::array<uint16_t, 1728> w136;
159 alignas(16) static std::array<uint16_t, 24> w137;
160 alignas(16) static std::array<uint16_t, 1728> w138;
161 alignas(16) static std::array<uint16_t, 72> w139;
162 alignas(16) static std::array<uint16_t, 2880> w140;
163 alignas(16) static std::array<uint16_t, 40> w141;
164 alignas(16) static std::array<uint16_t, 4800> w142;
165 alignas(16) static std::array<uint16_t, 120> w143;
166 alignas(16) static std::array<uint16_t, 3000> w144;
167 alignas(16) static std::array<uint16_t, 120> w145;
168 alignas(16) static std::array<uint16_t, 3840> w146;
169 alignas(16) static std::array<uint16_t, 32> w147;
170 alignas(16) static std::array<uint16_t, 3840> w148;
171 alignas(16) static std::array<uint16_t, 120> w149;
172 alignas(16) static std::array<uint16_t, 4800> w150;
173 alignas(16) static std::array<uint16_t, 40> w151;
174 alignas(16) static std::array<uint16_t, 4800> w152;
175 alignas(16) static std::array<uint16_t, 120> w153;
176 alignas(16) static std::array<uint16_t, 3000> w154;
177 alignas(16) static std::array<uint16_t, 120> w155;
178 alignas(16) static std::array<uint16_t, 3840> w156;
179 alignas(16) static std::array<uint16_t, 32> w157;
180 alignas(16) static std::array<uint16_t, 3840> w158;
181 alignas(16) static std::array<uint16_t, 120> w159;
182 alignas(16) static std::array<uint16_t, 4800> w160;
183 alignas(16) static std::array<uint16_t, 40> w161;
184 alignas(16) static std::array<uint16_t, 9600> w162;
185 alignas(16) static std::array<uint16_t, 240> w163;
186 alignas(16) static std::array<uint16_t, 2160> w164;
187 alignas(16) static std::array<uint16_t, 240> w165;
188 alignas(16) static std::array<uint16_t, 19200> w166;
189 alignas(16) static std::array<uint16_t, 80> w167;
190 alignas(16) static std::array<uint16_t, 16000> w168;
191 alignas(16) static std::array<uint16_t, 200> w169;
192 alignas(16) static std::array<uint16_t, 1800> w170;
193 alignas(16) static std::array<uint16_t, 200> w171;
194 alignas(16) static std::array<uint16_t, 16000> w172;
195 alignas(16) static std::array<uint16_t, 80> w173;
196 alignas(16) static std::array<uint16_t, 14720> w174;
197 alignas(16) static std::array<uint16_t, 184> w175;
198 alignas(16) static std::array<uint16_t, 1656> w176;
199 alignas(16) static std::array<uint16_t, 184> w177;
200 alignas(16) static std::array<uint16_t, 14720> w178;
201 alignas(16) static std::array<uint16_t, 80> w179;
202 alignas(16) static std::array<uint16_t, 14720> w180;
203 alignas(16) static std::array<uint16_t, 184> w181;
204 alignas(16) static std::array<uint16_t, 1656> w182;
205 alignas(16) static std::array<uint16_t, 184> w183;
206 alignas(16) static std::array<uint16_t, 14720> w184;
207 alignas(16) static std::array<uint16_t, 80> w185;
208 alignas(16) static std::array<uint16_t, 38400> w186;
209 alignas(16) static std::array<uint16_t, 480> w187;
210 alignas(16) static std::array<uint16_t, 4320> w188;
211 alignas(16) static std::array<uint16_t, 480> w189;
212 alignas(16) static std::array<uint16_t, 57600> w190;
213 alignas(16) static std::array<uint16_t, 120> w191;
214 alignas(16) static std::array<uint16_t, 57600> w192;
215 alignas(16) static std::array<uint16_t, 480> w193;
216 alignas(16) static std::array<uint16_t, 53760> w194;
217 alignas(16) static std::array<uint16_t, 112> w195;
218 alignas(16) static std::array<uint16_t, 75264> w196;
219 alignas(16) static std::array<uint16_t, 672> w197;
220 alignas(16) static std::array<uint16_t, 6048> w198;
221 alignas(16) static std::array<uint16_t, 672> w199;
222 alignas(16) static std::array<uint16_t, 112896> w200;
223 alignas(16) static std::array<uint16_t, 168> w201;
224 alignas(16) static std::array<uint16_t, 112896> w202;
225 alignas(16) static std::array<uint16_t, 672> w203;
226 alignas(16) static std::array<uint16_t, 75264> w204;
227 alignas(16) static std::array<uint16_t, 112> w205;
228 alignas(16) static std::array<uint16_t, 75264> w206;
229 alignas(16) static std::array<uint16_t, 672> w207;
230 alignas(16) static std::array<uint16_t, 16800> w208;
231 alignas(16) static std::array<uint16_t, 672> w209;
232 alignas(16) static std::array<uint16_t, 112896> w210;
233 alignas(16) static std::array<uint16_t, 168> w211;
234 alignas(16) static std::array<uint16_t, 112896> w212;
235 alignas(16) static std::array<uint16_t, 672> w213;
236 alignas(16) static std::array<uint16_t, 107520> w214;
237 alignas(16) static std::array<uint16_t, 160> w215;
238 alignas(16) static std::array<uint16_t, 153600> w216;
239 alignas(16) static std::array<uint16_t, 960> w217;
240 alignas(16) static std::array<uint16_t, 24000> w218;
241 alignas(16) static std::array<uint16_t, 960> w219;
242 alignas(16) static std::array<uint16_t, 230400> w220;
243 alignas(16) static std::array<uint16_t, 240> w221;
244 alignas(16) static std::array<uint16_t, 230400> w222;
245 alignas(16) static std::array<uint16_t, 960> w223;
246 alignas(16) static std::array<uint16_t, 153600> w224;
247 alignas(16) static std::array<uint16_t, 160> w225;
248 alignas(16) static std::array<uint16_t, 153600> w226;
249 alignas(16) static std::array<uint16_t, 960> w227;
250 alignas(16) static std::array<uint16_t, 24000> w228;
251 alignas(16) static std::array<uint16_t, 960> w229;
252 alignas(16) static std::array<uint16_t, 230400> w230;
253 alignas(16) static std::array<uint16_t, 240> w231;
254 alignas(16) static std::array<uint16_t, 230400> w232;
255 alignas(16) static std::array<uint16_t, 960> w233;
256 alignas(16) static std::array<uint16_t, 153600> w234;
257 alignas(16) static std::array<uint16_t, 160> w235;
258 alignas(16) static std::array<uint16_t, 153600> w236;
259 alignas(16) static std::array<uint16_t, 960> w237;
260 alignas(16) static std::array<uint16_t, 1228800> w238;
261 alignas(16) static std::array<uint16_t, 1280> w239;
262 alignas(16) static std::array<uint16_t, 1281280> w240;
263 alignas(16) static std::array<uint16_t, 1001> w241;
264
265 std::random_device random_device;
266 auto rng = std::mt19937(random_device());
267 auto f32rng = std::bind(std::uniform_real_distribution<float>(-1.0f, +1.0f), std::ref(rng));
268 auto f16rng = std::bind(fp16_ieee_from_fp32_value, f32rng);
269 std::generate(v0.begin(), v0.end(), std::ref(f16rng));
270 std::generate(v1.begin(), v1.end(), std::ref(f16rng));
271 std::generate(v2.begin(), v2.end(), std::ref(f16rng));
272 std::generate(v3.begin(), v3.end(), std::ref(f16rng));
273 std::generate(v4.begin(), v4.end(), std::ref(f16rng));
274 std::generate(v5.begin(), v5.end(), std::ref(f16rng));
275 std::generate(v6.begin(), v6.end(), std::ref(f16rng));
276 std::generate(v7.begin(), v7.end(), std::ref(f16rng));
277 std::generate(v8.begin(), v8.end(), std::ref(f16rng));
278 std::generate(v9.begin(), v9.end(), std::ref(f16rng));
279 std::generate(v10.begin(), v10.end(), std::ref(f16rng));
280 std::generate(v11.begin(), v11.end(), std::ref(f16rng));
281 std::generate(v12.begin(), v12.end(), std::ref(f16rng));
282 std::generate(v13.begin(), v13.end(), std::ref(f16rng));
283 std::generate(v14.begin(), v14.end(), std::ref(f16rng));
284 std::generate(v15.begin(), v15.end(), std::ref(f16rng));
285 std::generate(v16.begin(), v16.end(), std::ref(f16rng));
286 std::generate(v17.begin(), v17.end(), std::ref(f16rng));
287 std::generate(v18.begin(), v18.end(), std::ref(f16rng));
288 std::generate(v19.begin(), v19.end(), std::ref(f16rng));
289 std::generate(v20.begin(), v20.end(), std::ref(f16rng));
290 std::generate(v21.begin(), v21.end(), std::ref(f16rng));
291 std::generate(v22.begin(), v22.end(), std::ref(f16rng));
292 std::generate(v23.begin(), v23.end(), std::ref(f16rng));
293 std::generate(v24.begin(), v24.end(), std::ref(f16rng));
294 std::generate(v25.begin(), v25.end(), std::ref(f16rng));
295 std::generate(v26.begin(), v26.end(), std::ref(f16rng));
296 std::generate(v27.begin(), v27.end(), std::ref(f16rng));
297 std::generate(v28.begin(), v28.end(), std::ref(f16rng));
298 std::generate(v29.begin(), v29.end(), std::ref(f16rng));
299 std::generate(v30.begin(), v30.end(), std::ref(f16rng));
300 std::generate(v31.begin(), v31.end(), std::ref(f16rng));
301 std::generate(v32.begin(), v32.end(), std::ref(f16rng));
302 std::generate(v33.begin(), v33.end(), std::ref(f16rng));
303 std::generate(v34.begin(), v34.end(), std::ref(f16rng));
304 std::generate(v35.begin(), v35.end(), std::ref(f16rng));
305 std::generate(v36.begin(), v36.end(), std::ref(f16rng));
306 std::generate(v37.begin(), v37.end(), std::ref(f16rng));
307 std::generate(v38.begin(), v38.end(), std::ref(f16rng));
308 std::generate(v39.begin(), v39.end(), std::ref(f16rng));
309 std::generate(v40.begin(), v40.end(), std::ref(f16rng));
310 std::generate(v41.begin(), v41.end(), std::ref(f16rng));
311 std::generate(v42.begin(), v42.end(), std::ref(f16rng));
312 std::generate(v43.begin(), v43.end(), std::ref(f16rng));
313 std::generate(v44.begin(), v44.end(), std::ref(f16rng));
314 std::generate(v45.begin(), v45.end(), std::ref(f16rng));
315 std::generate(v46.begin(), v46.end(), std::ref(f16rng));
316 std::generate(v47.begin(), v47.end(), std::ref(f16rng));
317 std::generate(v48.begin(), v48.end(), std::ref(f16rng));
318 std::generate(v49.begin(), v49.end(), std::ref(f16rng));
319 std::generate(v50.begin(), v50.end(), std::ref(f16rng));
320 std::generate(v51.begin(), v51.end(), std::ref(f16rng));
321 std::generate(v52.begin(), v52.end(), std::ref(f16rng));
322 std::generate(v53.begin(), v53.end(), std::ref(f16rng));
323 std::generate(v54.begin(), v54.end(), std::ref(f16rng));
324 std::generate(v55.begin(), v55.end(), std::ref(f16rng));
325 std::generate(v56.begin(), v56.end(), std::ref(f16rng));
326 std::generate(v57.begin(), v57.end(), std::ref(f16rng));
327 std::generate(v58.begin(), v58.end(), std::ref(f16rng));
328 std::generate(v59.begin(), v59.end(), std::ref(f16rng));
329 std::generate(v60.begin(), v60.end(), std::ref(f16rng));
330 std::generate(v61.begin(), v61.end(), std::ref(f16rng));
331 std::generate(v62.begin(), v62.end(), std::ref(f16rng));
332 std::generate(v63.begin(), v63.end(), std::ref(f16rng));
333 std::generate(v64.begin(), v64.end(), std::ref(f16rng));
334 std::generate(v65.begin(), v65.end(), std::ref(f16rng));
335 std::generate(v66.begin(), v66.end(), std::ref(f16rng));
336 std::generate(v67.begin(), v67.end(), std::ref(f16rng));
337 std::generate(v68.begin(), v68.end(), std::ref(f16rng));
338 std::generate(v69.begin(), v69.end(), std::ref(f16rng));
339 std::generate(v70.begin(), v70.end(), std::ref(f16rng));
340 std::generate(v71.begin(), v71.end(), std::ref(f16rng));
341 std::generate(v72.begin(), v72.end(), std::ref(f16rng));
342 std::generate(v73.begin(), v73.end(), std::ref(f16rng));
343 std::generate(v74.begin(), v74.end(), std::ref(f16rng));
344 std::generate(v75.begin(), v75.end(), std::ref(f16rng));
345 std::generate(v76.begin(), v76.end(), std::ref(f16rng));
346 std::generate(v77.begin(), v77.end(), std::ref(f16rng));
347 std::generate(v78.begin(), v78.end(), std::ref(f16rng));
348 std::generate(v79.begin(), v79.end(), std::ref(f16rng));
349 std::generate(v80.begin(), v80.end(), std::ref(f16rng));
350 std::generate(v81.begin(), v81.end(), std::ref(f16rng));
351 std::generate(v82.begin(), v82.end(), std::ref(f16rng));
352 std::generate(v83.begin(), v83.end(), std::ref(f16rng));
353 std::generate(v84.begin(), v84.end(), std::ref(f16rng));
354 std::generate(v85.begin(), v85.end(), std::ref(f16rng));
355 std::generate(v86.begin(), v86.end(), std::ref(f16rng));
356 std::generate(v87.begin(), v87.end(), std::ref(f16rng));
357 std::generate(v88.begin(), v88.end(), std::ref(f16rng));
358 std::generate(v89.begin(), v89.end(), std::ref(f16rng));
359 std::generate(v90.begin(), v90.end(), std::ref(f16rng));
360 std::generate(v91.begin(), v91.end(), std::ref(f16rng));
361 std::generate(v92.begin(), v92.end(), std::ref(f16rng));
362 std::generate(v93.begin(), v93.end(), std::ref(f16rng));
363 std::generate(v94.begin(), v94.end(), std::ref(f16rng));
364 std::generate(v95.begin(), v95.end(), std::ref(f16rng));
365 std::generate(v96.begin(), v96.end(), std::ref(f16rng));
366 std::generate(v97.begin(), v97.end(), std::ref(f16rng));
367 std::generate(v98.begin(), v98.end(), std::ref(f16rng));
368 std::generate(v99.begin(), v99.end(), std::ref(f16rng));
369 std::generate(v100.begin(), v100.end(), std::ref(f16rng));
370 std::generate(v101.begin(), v101.end(), std::ref(f16rng));
371 std::generate(v102.begin(), v102.end(), std::ref(f16rng));
372 std::generate(v103.begin(), v103.end(), std::ref(f16rng));
373 std::generate(v104.begin(), v104.end(), std::ref(f16rng));
374 std::generate(v105.begin(), v105.end(), std::ref(f16rng));
375 std::generate(v106.begin(), v106.end(), std::ref(f16rng));
376 std::generate(v107.begin(), v107.end(), std::ref(f16rng));
377 std::generate(v108.begin(), v108.end(), std::ref(f16rng));
378 std::generate(v109.begin(), v109.end(), std::ref(f16rng));
379 std::generate(v110.begin(), v110.end(), std::ref(f16rng));
380 std::generate(v111.begin(), v111.end(), std::ref(f16rng));
381 std::generate(v112.begin(), v112.end(), std::ref(f16rng));
382 std::generate(v113.begin(), v113.end(), std::ref(f16rng));
383 std::generate(w114.begin(), w114.end(), std::ref(f16rng));
384 std::generate(w115.begin(), w115.end(), std::ref(f16rng));
385 std::generate(w116.begin(), w116.end(), std::ref(f16rng));
386 std::generate(w117.begin(), w117.end(), std::ref(f16rng));
387 std::generate(w118.begin(), w118.end(), std::ref(f16rng));
388 std::generate(w119.begin(), w119.end(), std::ref(f16rng));
389 std::generate(w120.begin(), w120.end(), std::ref(f16rng));
390 std::generate(w121.begin(), w121.end(), std::ref(f16rng));
391 std::generate(w122.begin(), w122.end(), std::ref(f16rng));
392 std::generate(w123.begin(), w123.end(), std::ref(f16rng));
393 std::generate(w124.begin(), w124.end(), std::ref(f16rng));
394 std::generate(w125.begin(), w125.end(), std::ref(f16rng));
395 std::generate(w126.begin(), w126.end(), std::ref(f16rng));
396 std::generate(w127.begin(), w127.end(), std::ref(f16rng));
397 std::generate(w128.begin(), w128.end(), std::ref(f16rng));
398 std::generate(w129.begin(), w129.end(), std::ref(f16rng));
399 std::generate(w130.begin(), w130.end(), std::ref(f16rng));
400 std::generate(w131.begin(), w131.end(), std::ref(f16rng));
401 std::generate(w132.begin(), w132.end(), std::ref(f16rng));
402 std::generate(w133.begin(), w133.end(), std::ref(f16rng));
403 std::generate(w134.begin(), w134.end(), std::ref(f16rng));
404 std::generate(w135.begin(), w135.end(), std::ref(f16rng));
405 std::generate(w136.begin(), w136.end(), std::ref(f16rng));
406 std::generate(w137.begin(), w137.end(), std::ref(f16rng));
407 std::generate(w138.begin(), w138.end(), std::ref(f16rng));
408 std::generate(w139.begin(), w139.end(), std::ref(f16rng));
409 std::generate(w140.begin(), w140.end(), std::ref(f16rng));
410 std::generate(w141.begin(), w141.end(), std::ref(f16rng));
411 std::generate(w142.begin(), w142.end(), std::ref(f16rng));
412 std::generate(w143.begin(), w143.end(), std::ref(f16rng));
413 std::generate(w144.begin(), w144.end(), std::ref(f16rng));
414 std::generate(w145.begin(), w145.end(), std::ref(f16rng));
415 std::generate(w146.begin(), w146.end(), std::ref(f16rng));
416 std::generate(w147.begin(), w147.end(), std::ref(f16rng));
417 std::generate(w148.begin(), w148.end(), std::ref(f16rng));
418 std::generate(w149.begin(), w149.end(), std::ref(f16rng));
419 std::generate(w150.begin(), w150.end(), std::ref(f16rng));
420 std::generate(w151.begin(), w151.end(), std::ref(f16rng));
421 std::generate(w152.begin(), w152.end(), std::ref(f16rng));
422 std::generate(w153.begin(), w153.end(), std::ref(f16rng));
423 std::generate(w154.begin(), w154.end(), std::ref(f16rng));
424 std::generate(w155.begin(), w155.end(), std::ref(f16rng));
425 std::generate(w156.begin(), w156.end(), std::ref(f16rng));
426 std::generate(w157.begin(), w157.end(), std::ref(f16rng));
427 std::generate(w158.begin(), w158.end(), std::ref(f16rng));
428 std::generate(w159.begin(), w159.end(), std::ref(f16rng));
429 std::generate(w160.begin(), w160.end(), std::ref(f16rng));
430 std::generate(w161.begin(), w161.end(), std::ref(f16rng));
431 std::generate(w162.begin(), w162.end(), std::ref(f16rng));
432 std::generate(w163.begin(), w163.end(), std::ref(f16rng));
433 std::generate(w164.begin(), w164.end(), std::ref(f16rng));
434 std::generate(w165.begin(), w165.end(), std::ref(f16rng));
435 std::generate(w166.begin(), w166.end(), std::ref(f16rng));
436 std::generate(w167.begin(), w167.end(), std::ref(f16rng));
437 std::generate(w168.begin(), w168.end(), std::ref(f16rng));
438 std::generate(w169.begin(), w169.end(), std::ref(f16rng));
439 std::generate(w170.begin(), w170.end(), std::ref(f16rng));
440 std::generate(w171.begin(), w171.end(), std::ref(f16rng));
441 std::generate(w172.begin(), w172.end(), std::ref(f16rng));
442 std::generate(w173.begin(), w173.end(), std::ref(f16rng));
443 std::generate(w174.begin(), w174.end(), std::ref(f16rng));
444 std::generate(w175.begin(), w175.end(), std::ref(f16rng));
445 std::generate(w176.begin(), w176.end(), std::ref(f16rng));
446 std::generate(w177.begin(), w177.end(), std::ref(f16rng));
447 std::generate(w178.begin(), w178.end(), std::ref(f16rng));
448 std::generate(w179.begin(), w179.end(), std::ref(f16rng));
449 std::generate(w180.begin(), w180.end(), std::ref(f16rng));
450 std::generate(w181.begin(), w181.end(), std::ref(f16rng));
451 std::generate(w182.begin(), w182.end(), std::ref(f16rng));
452 std::generate(w183.begin(), w183.end(), std::ref(f16rng));
453 std::generate(w184.begin(), w184.end(), std::ref(f16rng));
454 std::generate(w185.begin(), w185.end(), std::ref(f16rng));
455 std::generate(w186.begin(), w186.end(), std::ref(f16rng));
456 std::generate(w187.begin(), w187.end(), std::ref(f16rng));
457 std::generate(w188.begin(), w188.end(), std::ref(f16rng));
458 std::generate(w189.begin(), w189.end(), std::ref(f16rng));
459 std::generate(w190.begin(), w190.end(), std::ref(f16rng));
460 std::generate(w191.begin(), w191.end(), std::ref(f16rng));
461 std::generate(w192.begin(), w192.end(), std::ref(f16rng));
462 std::generate(w193.begin(), w193.end(), std::ref(f16rng));
463 std::generate(w194.begin(), w194.end(), std::ref(f16rng));
464 std::generate(w195.begin(), w195.end(), std::ref(f16rng));
465 std::generate(w196.begin(), w196.end(), std::ref(f16rng));
466 std::generate(w197.begin(), w197.end(), std::ref(f16rng));
467 std::generate(w198.begin(), w198.end(), std::ref(f16rng));
468 std::generate(w199.begin(), w199.end(), std::ref(f16rng));
469 std::generate(w200.begin(), w200.end(), std::ref(f16rng));
470 std::generate(w201.begin(), w201.end(), std::ref(f16rng));
471 std::generate(w202.begin(), w202.end(), std::ref(f16rng));
472 std::generate(w203.begin(), w203.end(), std::ref(f16rng));
473 std::generate(w204.begin(), w204.end(), std::ref(f16rng));
474 std::generate(w205.begin(), w205.end(), std::ref(f16rng));
475 std::generate(w206.begin(), w206.end(), std::ref(f16rng));
476 std::generate(w207.begin(), w207.end(), std::ref(f16rng));
477 std::generate(w208.begin(), w208.end(), std::ref(f16rng));
478 std::generate(w209.begin(), w209.end(), std::ref(f16rng));
479 std::generate(w210.begin(), w210.end(), std::ref(f16rng));
480 std::generate(w211.begin(), w211.end(), std::ref(f16rng));
481 std::generate(w212.begin(), w212.end(), std::ref(f16rng));
482 std::generate(w213.begin(), w213.end(), std::ref(f16rng));
483 std::generate(w214.begin(), w214.end(), std::ref(f16rng));
484 std::generate(w215.begin(), w215.end(), std::ref(f16rng));
485 std::generate(w216.begin(), w216.end(), std::ref(f16rng));
486 std::generate(w217.begin(), w217.end(), std::ref(f16rng));
487 std::generate(w218.begin(), w218.end(), std::ref(f16rng));
488 std::generate(w219.begin(), w219.end(), std::ref(f16rng));
489 std::generate(w220.begin(), w220.end(), std::ref(f16rng));
490 std::generate(w221.begin(), w221.end(), std::ref(f16rng));
491 std::generate(w222.begin(), w222.end(), std::ref(f16rng));
492 std::generate(w223.begin(), w223.end(), std::ref(f16rng));
493 std::generate(w224.begin(), w224.end(), std::ref(f16rng));
494 std::generate(w225.begin(), w225.end(), std::ref(f16rng));
495 std::generate(w226.begin(), w226.end(), std::ref(f16rng));
496 std::generate(w227.begin(), w227.end(), std::ref(f16rng));
497 std::generate(w228.begin(), w228.end(), std::ref(f16rng));
498 std::generate(w229.begin(), w229.end(), std::ref(f16rng));
499 std::generate(w230.begin(), w230.end(), std::ref(f16rng));
500 std::generate(w231.begin(), w231.end(), std::ref(f16rng));
501 std::generate(w232.begin(), w232.end(), std::ref(f16rng));
502 std::generate(w233.begin(), w233.end(), std::ref(f16rng));
503 std::generate(w234.begin(), w234.end(), std::ref(f16rng));
504 std::generate(w235.begin(), w235.end(), std::ref(f16rng));
505 std::generate(w236.begin(), w236.end(), std::ref(f16rng));
506 std::generate(w237.begin(), w237.end(), std::ref(f16rng));
507 std::generate(w238.begin(), w238.end(), std::ref(f16rng));
508 std::generate(w239.begin(), w239.end(), std::ref(f16rng));
509 std::generate(w240.begin(), w240.end(), std::ref(f16rng));
510 std::generate(w241.begin(), w241.end(), std::ref(f16rng));
511
512 ExecutionPlan operators;
513 xnn_status status;
514
515 xnn_operator_t op0 = nullptr;
516 status = xnn_create_convolution2d_nhwc_f16(
517 0 /* top padding */, 1 /* right padding */,
518 1 /* bottom padding */, 0 /* left padding */,
519 3 /* kernel height */, 3 /* kernel width */,
520 2 /* subsampling height */, 2 /* subsampling width */,
521 1 /* dilation_height */, 1 /* dilation_width */,
522 1 /* groups */,
523 3 /* input channels per group */,
524 16 /* output_channels_per_group */,
525 3 /* input pixel stride */,
526 16 /* output pixel stride */,
527 w114.data(), w115.data(),
528 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
529 0 /* flags */,
530 &op0);
531 if (status != xnn_status_success) {
532 std::cerr << "failed to create operation #0" << std::endl;
533 return ExecutionPlan();
534 }
535 operators.emplace_back(op0, xnn_delete_operator);
536
537 xnn_operator_t op1 = nullptr;
538 status = xnn_create_hardswish_nc_f16(
539 16 /* channels */,
540 16 /* input stride */,
541 16 /* output stride */,
542 0 /* flags */,
543 &op1);
544 if (status != xnn_status_success) {
545 std::cerr << "failed to create operation #1" << std::endl;
546 return ExecutionPlan();
547 }
548 operators.emplace_back(op1, xnn_delete_operator);
549
550 xnn_operator_t op2 = nullptr;
551 status = xnn_create_convolution2d_nhwc_f16(
552 1 /* top padding */, 1 /* right padding */,
553 1 /* bottom padding */, 1 /* left padding */,
554 3 /* kernel height */, 3 /* kernel width */,
555 1 /* subsampling height */, 1 /* subsampling width */,
556 1 /* dilation_height */, 1 /* dilation_width */,
557 16 /* groups */,
558 1 /* input channels per group */,
559 1 /* output_channels_per_group */,
560 16 /* input pixel stride */,
561 16 /* output pixel stride */,
562 w116.data(), w117.data(),
563 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
564 0 /* flags */,
565 &op2);
566 if (status != xnn_status_success) {
567 std::cerr << "failed to create operation #2" << std::endl;
568 return ExecutionPlan();
569 }
570 operators.emplace_back(op2, xnn_delete_operator);
571
572 xnn_operator_t op3 = nullptr;
573 status = xnn_create_convolution2d_nhwc_f16(
574 0 /* top padding */, 0 /* right padding */,
575 0 /* bottom padding */, 0 /* left padding */,
576 1 /* kernel height */, 1 /* kernel width */,
577 1 /* subsampling height */, 1 /* subsampling width */,
578 1 /* dilation_height */, 1 /* dilation_width */,
579 1 /* groups */,
580 16 /* input channels per group */,
581 16 /* output_channels_per_group */,
582 16 /* input pixel stride */,
583 16 /* output pixel stride */,
584 w118.data(), w119.data(),
585 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
586 0 /* flags */,
587 &op3);
588 if (status != xnn_status_success) {
589 std::cerr << "failed to create operation #3" << std::endl;
590 return ExecutionPlan();
591 }
592 operators.emplace_back(op3, xnn_delete_operator);
593
594 xnn_operator_t op4 = nullptr;
595 status = xnn_create_add_nd_f16(
596 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
597 0 /* flags */,
598 &op4);
599 if (status != xnn_status_success) {
600 std::cerr << "failed to create operation #4" << std::endl;
601 return ExecutionPlan();
602 }
603 operators.emplace_back(op4, xnn_delete_operator);
604
605 xnn_operator_t op5 = nullptr;
606 status = xnn_create_convolution2d_nhwc_f16(
607 0 /* top padding */, 0 /* right padding */,
608 0 /* bottom padding */, 0 /* left padding */,
609 1 /* kernel height */, 1 /* kernel width */,
610 1 /* subsampling height */, 1 /* subsampling width */,
611 1 /* dilation_height */, 1 /* dilation_width */,
612 1 /* groups */,
613 16 /* input channels per group */,
614 64 /* output_channels_per_group */,
615 16 /* input pixel stride */,
616 64 /* output pixel stride */,
617 w120.data(), w121.data(),
618 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
619 0 /* flags */,
620 &op5);
621 if (status != xnn_status_success) {
622 std::cerr << "failed to create operation #5" << std::endl;
623 return ExecutionPlan();
624 }
625 operators.emplace_back(op5, xnn_delete_operator);
626
627 xnn_operator_t op6 = nullptr;
628 status = xnn_create_convolution2d_nhwc_f16(
629 0 /* top padding */, 1 /* right padding */,
630 1 /* bottom padding */, 0 /* left padding */,
631 3 /* kernel height */, 3 /* kernel width */,
632 2 /* subsampling height */, 2 /* subsampling width */,
633 1 /* dilation_height */, 1 /* dilation_width */,
634 64 /* groups */,
635 1 /* input channels per group */,
636 1 /* output_channels_per_group */,
637 64 /* input pixel stride */,
638 64 /* output pixel stride */,
639 w122.data(), w123.data(),
640 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
641 0 /* flags */,
642 &op6);
643 if (status != xnn_status_success) {
644 std::cerr << "failed to create operation #6" << std::endl;
645 return ExecutionPlan();
646 }
647 operators.emplace_back(op6, xnn_delete_operator);
648
649 xnn_operator_t op7 = nullptr;
650 status = xnn_create_convolution2d_nhwc_f16(
651 0 /* top padding */, 0 /* right padding */,
652 0 /* bottom padding */, 0 /* left padding */,
653 1 /* kernel height */, 1 /* kernel width */,
654 1 /* subsampling height */, 1 /* subsampling width */,
655 1 /* dilation_height */, 1 /* dilation_width */,
656 1 /* groups */,
657 64 /* input channels per group */,
658 24 /* output_channels_per_group */,
659 64 /* input pixel stride */,
660 24 /* output pixel stride */,
661 w124.data(), w125.data(),
662 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
663 0 /* flags */,
664 &op7);
665 if (status != xnn_status_success) {
666 std::cerr << "failed to create operation #7" << std::endl;
667 return ExecutionPlan();
668 }
669 operators.emplace_back(op7, xnn_delete_operator);
670
671 xnn_operator_t op8 = nullptr;
672 status = xnn_create_convolution2d_nhwc_f16(
673 0 /* top padding */, 0 /* right padding */,
674 0 /* bottom padding */, 0 /* left padding */,
675 1 /* kernel height */, 1 /* kernel width */,
676 1 /* subsampling height */, 1 /* subsampling width */,
677 1 /* dilation_height */, 1 /* dilation_width */,
678 1 /* groups */,
679 24 /* input channels per group */,
680 72 /* output_channels_per_group */,
681 24 /* input pixel stride */,
682 72 /* output pixel stride */,
683 w126.data(), w127.data(),
684 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
685 0 /* flags */,
686 &op8);
687 if (status != xnn_status_success) {
688 std::cerr << "failed to create operation #8" << std::endl;
689 return ExecutionPlan();
690 }
691 operators.emplace_back(op8, xnn_delete_operator);
692
693 xnn_operator_t op9 = nullptr;
694 status = xnn_create_convolution2d_nhwc_f16(
695 1 /* top padding */, 1 /* right padding */,
696 1 /* bottom padding */, 1 /* left padding */,
697 3 /* kernel height */, 3 /* kernel width */,
698 1 /* subsampling height */, 1 /* subsampling width */,
699 1 /* dilation_height */, 1 /* dilation_width */,
700 72 /* groups */,
701 1 /* input channels per group */,
702 1 /* output_channels_per_group */,
703 72 /* input pixel stride */,
704 72 /* output pixel stride */,
705 w128.data(), w129.data(),
706 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
707 0 /* flags */,
708 &op9);
709 if (status != xnn_status_success) {
710 std::cerr << "failed to create operation #9" << std::endl;
711 return ExecutionPlan();
712 }
713 operators.emplace_back(op9, xnn_delete_operator);
714
715 xnn_operator_t op10 = nullptr;
716 status = xnn_create_convolution2d_nhwc_f16(
717 0 /* top padding */, 0 /* right padding */,
718 0 /* bottom padding */, 0 /* left padding */,
719 1 /* kernel height */, 1 /* kernel width */,
720 1 /* subsampling height */, 1 /* subsampling width */,
721 1 /* dilation_height */, 1 /* dilation_width */,
722 1 /* groups */,
723 72 /* input channels per group */,
724 24 /* output_channels_per_group */,
725 72 /* input pixel stride */,
726 24 /* output pixel stride */,
727 w130.data(), w131.data(),
728 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
729 0 /* flags */,
730 &op10);
731 if (status != xnn_status_success) {
732 std::cerr << "failed to create operation #10" << std::endl;
733 return ExecutionPlan();
734 }
735 operators.emplace_back(op10, xnn_delete_operator);
736
737 xnn_operator_t op11 = nullptr;
738 status = xnn_create_add_nd_f16(
739 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
740 0 /* flags */,
741 &op11);
742 if (status != xnn_status_success) {
743 std::cerr << "failed to create operation #11" << std::endl;
744 return ExecutionPlan();
745 }
746 operators.emplace_back(op11, xnn_delete_operator);
747
748 xnn_operator_t op12 = nullptr;
749 status = xnn_create_convolution2d_nhwc_f16(
750 0 /* top padding */, 0 /* right padding */,
751 0 /* bottom padding */, 0 /* left padding */,
752 1 /* kernel height */, 1 /* kernel width */,
753 1 /* subsampling height */, 1 /* subsampling width */,
754 1 /* dilation_height */, 1 /* dilation_width */,
755 1 /* groups */,
756 24 /* input channels per group */,
757 72 /* output_channels_per_group */,
758 24 /* input pixel stride */,
759 72 /* output pixel stride */,
760 w132.data(), w133.data(),
761 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
762 0 /* flags */,
763 &op12);
764 if (status != xnn_status_success) {
765 std::cerr << "failed to create operation #12" << std::endl;
766 return ExecutionPlan();
767 }
768 operators.emplace_back(op12, xnn_delete_operator);
769
770 xnn_operator_t op13 = nullptr;
771 status = xnn_create_convolution2d_nhwc_f16(
772 1 /* top padding */, 2 /* right padding */,
773 2 /* bottom padding */, 1 /* left padding */,
774 5 /* kernel height */, 5 /* kernel width */,
775 2 /* subsampling height */, 2 /* subsampling width */,
776 1 /* dilation_height */, 1 /* dilation_width */,
777 72 /* groups */,
778 1 /* input channels per group */,
779 1 /* output_channels_per_group */,
780 72 /* input pixel stride */,
781 72 /* output pixel stride */,
782 w134.data(), w135.data(),
783 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
784 0 /* flags */,
785 &op13);
786 if (status != xnn_status_success) {
787 std::cerr << "failed to create operation #13" << std::endl;
788 return ExecutionPlan();
789 }
790 operators.emplace_back(op13, xnn_delete_operator);
791
792 xnn_operator_t op14 = nullptr;
793 status = xnn_create_global_average_pooling_nwc_f16(
794 72 /* channels */, 72 /* input stride */, 72 /* output stride */,
795 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
796 0 /* flags */,
797 &op14);
798 if (status != xnn_status_success) {
799 std::cerr << "failed to create operation #14" << std::endl;
800 return ExecutionPlan();
801 }
802 operators.emplace_back(op14, xnn_delete_operator);
803
804 xnn_operator_t op15 = nullptr;
805 status = xnn_create_convolution2d_nhwc_f16(
806 0 /* top padding */, 0 /* right padding */,
807 0 /* bottom padding */, 0 /* left padding */,
808 1 /* kernel height */, 1 /* kernel width */,
809 1 /* subsampling height */, 1 /* subsampling width */,
810 1 /* dilation_height */, 1 /* dilation_width */,
811 1 /* groups */,
812 72 /* input channels per group */,
813 24 /* output_channels_per_group */,
814 72 /* input pixel stride */,
815 24 /* output pixel stride */,
816 w136.data(), w137.data(),
817 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
818 0 /* flags */,
819 &op15);
820 if (status != xnn_status_success) {
821 std::cerr << "failed to create operation #15" << std::endl;
822 return ExecutionPlan();
823 }
824 operators.emplace_back(op15, xnn_delete_operator);
825
826 xnn_operator_t op16 = nullptr;
827 status = xnn_create_convolution2d_nhwc_f16(
828 0 /* top padding */, 0 /* right padding */,
829 0 /* bottom padding */, 0 /* left padding */,
830 1 /* kernel height */, 1 /* kernel width */,
831 1 /* subsampling height */, 1 /* subsampling width */,
832 1 /* dilation_height */, 1 /* dilation_width */,
833 1 /* groups */,
834 24 /* input channels per group */,
835 72 /* output_channels_per_group */,
836 24 /* input pixel stride */,
837 72 /* output pixel stride */,
838 w138.data(), w139.data(),
839 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
840 0 /* flags */,
841 &op16);
842 if (status != xnn_status_success) {
843 std::cerr << "failed to create operation #16" << std::endl;
844 return ExecutionPlan();
845 }
846 operators.emplace_back(op16, xnn_delete_operator);
847
848 xnn_operator_t op17 = nullptr;
849 status = xnn_create_multiply_nd_f16(
850 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
851 0 /* flags */,
852 &op17);
853 if (status != xnn_status_success) {
854 std::cerr << "failed to create operation #17" << std::endl;
855 return ExecutionPlan();
856 }
857 operators.emplace_back(op17, xnn_delete_operator);
858
859 xnn_operator_t op18 = nullptr;
860 status = xnn_create_convolution2d_nhwc_f16(
861 0 /* top padding */, 0 /* right padding */,
862 0 /* bottom padding */, 0 /* left padding */,
863 1 /* kernel height */, 1 /* kernel width */,
864 1 /* subsampling height */, 1 /* subsampling width */,
865 1 /* dilation_height */, 1 /* dilation_width */,
866 1 /* groups */,
867 72 /* input channels per group */,
868 40 /* output_channels_per_group */,
869 72 /* input pixel stride */,
870 40 /* output pixel stride */,
871 w140.data(), w141.data(),
872 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
873 0 /* flags */,
874 &op18);
875 if (status != xnn_status_success) {
876 std::cerr << "failed to create operation #18" << std::endl;
877 return ExecutionPlan();
878 }
879 operators.emplace_back(op18, xnn_delete_operator);
880
881 xnn_operator_t op19 = nullptr;
882 status = xnn_create_convolution2d_nhwc_f16(
883 0 /* top padding */, 0 /* right padding */,
884 0 /* bottom padding */, 0 /* left padding */,
885 1 /* kernel height */, 1 /* kernel width */,
886 1 /* subsampling height */, 1 /* subsampling width */,
887 1 /* dilation_height */, 1 /* dilation_width */,
888 1 /* groups */,
889 40 /* input channels per group */,
890 120 /* output_channels_per_group */,
891 40 /* input pixel stride */,
892 120 /* output pixel stride */,
893 w142.data(), w143.data(),
894 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
895 0 /* flags */,
896 &op19);
897 if (status != xnn_status_success) {
898 std::cerr << "failed to create operation #19" << std::endl;
899 return ExecutionPlan();
900 }
901 operators.emplace_back(op19, xnn_delete_operator);
902
903 xnn_operator_t op20 = nullptr;
904 status = xnn_create_convolution2d_nhwc_f16(
905 2 /* top padding */, 2 /* right padding */,
906 2 /* bottom padding */, 2 /* left padding */,
907 5 /* kernel height */, 5 /* kernel width */,
908 1 /* subsampling height */, 1 /* subsampling width */,
909 1 /* dilation_height */, 1 /* dilation_width */,
910 120 /* groups */,
911 1 /* input channels per group */,
912 1 /* output_channels_per_group */,
913 120 /* input pixel stride */,
914 120 /* output pixel stride */,
915 w144.data(), w145.data(),
916 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
917 0 /* flags */,
918 &op20);
919 if (status != xnn_status_success) {
920 std::cerr << "failed to create operation #20" << std::endl;
921 return ExecutionPlan();
922 }
923 operators.emplace_back(op20, xnn_delete_operator);
924
925 xnn_operator_t op21 = nullptr;
926 status = xnn_create_global_average_pooling_nwc_f16(
927 120 /* channels */, 120 /* input stride */, 120 /* output stride */,
928 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
929 0 /* flags */,
930 &op21);
931 if (status != xnn_status_success) {
932 std::cerr << "failed to create operation #21" << std::endl;
933 return ExecutionPlan();
934 }
935 operators.emplace_back(op21, xnn_delete_operator);
936
937 xnn_operator_t op22 = nullptr;
938 status = xnn_create_convolution2d_nhwc_f16(
939 0 /* top padding */, 0 /* right padding */,
940 0 /* bottom padding */, 0 /* left padding */,
941 1 /* kernel height */, 1 /* kernel width */,
942 1 /* subsampling height */, 1 /* subsampling width */,
943 1 /* dilation_height */, 1 /* dilation_width */,
944 1 /* groups */,
945 120 /* input channels per group */,
946 32 /* output_channels_per_group */,
947 120 /* input pixel stride */,
948 32 /* output pixel stride */,
949 w146.data(), w147.data(),
950 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
951 0 /* flags */,
952 &op22);
953 if (status != xnn_status_success) {
954 std::cerr << "failed to create operation #22" << std::endl;
955 return ExecutionPlan();
956 }
957 operators.emplace_back(op22, xnn_delete_operator);
958
959 xnn_operator_t op23 = nullptr;
960 status = xnn_create_convolution2d_nhwc_f16(
961 0 /* top padding */, 0 /* right padding */,
962 0 /* bottom padding */, 0 /* left padding */,
963 1 /* kernel height */, 1 /* kernel width */,
964 1 /* subsampling height */, 1 /* subsampling width */,
965 1 /* dilation_height */, 1 /* dilation_width */,
966 1 /* groups */,
967 32 /* input channels per group */,
968 120 /* output_channels_per_group */,
969 32 /* input pixel stride */,
970 120 /* output pixel stride */,
971 w148.data(), w149.data(),
972 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
973 0 /* flags */,
974 &op23);
975 if (status != xnn_status_success) {
976 std::cerr << "failed to create operation #23" << std::endl;
977 return ExecutionPlan();
978 }
979 operators.emplace_back(op23, xnn_delete_operator);
980
981 xnn_operator_t op24 = nullptr;
982 status = xnn_create_multiply_nd_f16(
983 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
984 0 /* flags */,
985 &op24);
986 if (status != xnn_status_success) {
987 std::cerr << "failed to create operation #24" << std::endl;
988 return ExecutionPlan();
989 }
990 operators.emplace_back(op24, xnn_delete_operator);
991
992 xnn_operator_t op25 = nullptr;
993 status = xnn_create_convolution2d_nhwc_f16(
994 0 /* top padding */, 0 /* right padding */,
995 0 /* bottom padding */, 0 /* left padding */,
996 1 /* kernel height */, 1 /* kernel width */,
997 1 /* subsampling height */, 1 /* subsampling width */,
998 1 /* dilation_height */, 1 /* dilation_width */,
999 1 /* groups */,
1000 120 /* input channels per group */,
1001 40 /* output_channels_per_group */,
1002 120 /* input pixel stride */,
1003 40 /* output pixel stride */,
1004 w150.data(), w151.data(),
1005 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1006 0 /* flags */,
1007 &op25);
1008 if (status != xnn_status_success) {
1009 std::cerr << "failed to create operation #25" << std::endl;
1010 return ExecutionPlan();
1011 }
1012 operators.emplace_back(op25, xnn_delete_operator);
1013
1014 xnn_operator_t op26 = nullptr;
1015 status = xnn_create_add_nd_f16(
1016 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1017 0 /* flags */,
1018 &op26);
1019 if (status != xnn_status_success) {
1020 std::cerr << "failed to create operation #26" << std::endl;
1021 return ExecutionPlan();
1022 }
1023 operators.emplace_back(op26, xnn_delete_operator);
1024
1025 xnn_operator_t op27 = nullptr;
1026 status = xnn_create_convolution2d_nhwc_f16(
1027 0 /* top padding */, 0 /* right padding */,
1028 0 /* bottom padding */, 0 /* left padding */,
1029 1 /* kernel height */, 1 /* kernel width */,
1030 1 /* subsampling height */, 1 /* subsampling width */,
1031 1 /* dilation_height */, 1 /* dilation_width */,
1032 1 /* groups */,
1033 40 /* input channels per group */,
1034 120 /* output_channels_per_group */,
1035 40 /* input pixel stride */,
1036 120 /* output pixel stride */,
1037 w152.data(), w153.data(),
1038 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1039 0 /* flags */,
1040 &op27);
1041 if (status != xnn_status_success) {
1042 std::cerr << "failed to create operation #27" << std::endl;
1043 return ExecutionPlan();
1044 }
1045 operators.emplace_back(op27, xnn_delete_operator);
1046
1047 xnn_operator_t op28 = nullptr;
1048 status = xnn_create_convolution2d_nhwc_f16(
1049 2 /* top padding */, 2 /* right padding */,
1050 2 /* bottom padding */, 2 /* left padding */,
1051 5 /* kernel height */, 5 /* kernel width */,
1052 1 /* subsampling height */, 1 /* subsampling width */,
1053 1 /* dilation_height */, 1 /* dilation_width */,
1054 120 /* groups */,
1055 1 /* input channels per group */,
1056 1 /* output_channels_per_group */,
1057 120 /* input pixel stride */,
1058 120 /* output pixel stride */,
1059 w154.data(), w155.data(),
1060 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1061 0 /* flags */,
1062 &op28);
1063 if (status != xnn_status_success) {
1064 std::cerr << "failed to create operation #28" << std::endl;
1065 return ExecutionPlan();
1066 }
1067 operators.emplace_back(op28, xnn_delete_operator);
1068
1069 xnn_operator_t op29 = nullptr;
1070 status = xnn_create_global_average_pooling_nwc_f16(
1071 120 /* channels */, 120 /* input stride */, 120 /* output stride */,
1072 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1073 0 /* flags */,
1074 &op29);
1075 if (status != xnn_status_success) {
1076 std::cerr << "failed to create operation #29" << std::endl;
1077 return ExecutionPlan();
1078 }
1079 operators.emplace_back(op29, xnn_delete_operator);
1080
1081 xnn_operator_t op30 = nullptr;
1082 status = xnn_create_convolution2d_nhwc_f16(
1083 0 /* top padding */, 0 /* right padding */,
1084 0 /* bottom padding */, 0 /* left padding */,
1085 1 /* kernel height */, 1 /* kernel width */,
1086 1 /* subsampling height */, 1 /* subsampling width */,
1087 1 /* dilation_height */, 1 /* dilation_width */,
1088 1 /* groups */,
1089 120 /* input channels per group */,
1090 32 /* output_channels_per_group */,
1091 120 /* input pixel stride */,
1092 32 /* output pixel stride */,
1093 w156.data(), w157.data(),
1094 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1095 0 /* flags */,
1096 &op30);
1097 if (status != xnn_status_success) {
1098 std::cerr << "failed to create operation #30" << std::endl;
1099 return ExecutionPlan();
1100 }
1101 operators.emplace_back(op30, xnn_delete_operator);
1102
1103 xnn_operator_t op31 = nullptr;
1104 status = xnn_create_convolution2d_nhwc_f16(
1105 0 /* top padding */, 0 /* right padding */,
1106 0 /* bottom padding */, 0 /* left padding */,
1107 1 /* kernel height */, 1 /* kernel width */,
1108 1 /* subsampling height */, 1 /* subsampling width */,
1109 1 /* dilation_height */, 1 /* dilation_width */,
1110 1 /* groups */,
1111 32 /* input channels per group */,
1112 120 /* output_channels_per_group */,
1113 32 /* input pixel stride */,
1114 120 /* output pixel stride */,
1115 w158.data(), w159.data(),
1116 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
1117 0 /* flags */,
1118 &op31);
1119 if (status != xnn_status_success) {
1120 std::cerr << "failed to create operation #31" << std::endl;
1121 return ExecutionPlan();
1122 }
1123 operators.emplace_back(op31, xnn_delete_operator);
1124
1125 xnn_operator_t op32 = nullptr;
1126 status = xnn_create_multiply_nd_f16(
1127 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1128 0 /* flags */,
1129 &op32);
1130 if (status != xnn_status_success) {
1131 std::cerr << "failed to create operation #32" << std::endl;
1132 return ExecutionPlan();
1133 }
1134 operators.emplace_back(op32, xnn_delete_operator);
1135
1136 xnn_operator_t op33 = nullptr;
1137 status = xnn_create_convolution2d_nhwc_f16(
1138 0 /* top padding */, 0 /* right padding */,
1139 0 /* bottom padding */, 0 /* left padding */,
1140 1 /* kernel height */, 1 /* kernel width */,
1141 1 /* subsampling height */, 1 /* subsampling width */,
1142 1 /* dilation_height */, 1 /* dilation_width */,
1143 1 /* groups */,
1144 120 /* input channels per group */,
1145 40 /* output_channels_per_group */,
1146 120 /* input pixel stride */,
1147 40 /* output pixel stride */,
1148 w160.data(), w161.data(),
1149 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1150 0 /* flags */,
1151 &op33);
1152 if (status != xnn_status_success) {
1153 std::cerr << "failed to create operation #33" << std::endl;
1154 return ExecutionPlan();
1155 }
1156 operators.emplace_back(op33, xnn_delete_operator);
1157
1158 xnn_operator_t op34 = nullptr;
1159 status = xnn_create_add_nd_f16(
1160 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1161 0 /* flags */,
1162 &op34);
1163 if (status != xnn_status_success) {
1164 std::cerr << "failed to create operation #34" << std::endl;
1165 return ExecutionPlan();
1166 }
1167 operators.emplace_back(op34, xnn_delete_operator);
1168
1169 xnn_operator_t op35 = nullptr;
1170 status = xnn_create_convolution2d_nhwc_f16(
1171 0 /* top padding */, 0 /* right padding */,
1172 0 /* bottom padding */, 0 /* left padding */,
1173 1 /* kernel height */, 1 /* kernel width */,
1174 1 /* subsampling height */, 1 /* subsampling width */,
1175 1 /* dilation_height */, 1 /* dilation_width */,
1176 1 /* groups */,
1177 40 /* input channels per group */,
1178 240 /* output_channels_per_group */,
1179 40 /* input pixel stride */,
1180 240 /* output pixel stride */,
1181 w162.data(), w163.data(),
1182 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1183 0 /* flags */,
1184 &op35);
1185 if (status != xnn_status_success) {
1186 std::cerr << "failed to create operation #35" << std::endl;
1187 return ExecutionPlan();
1188 }
1189 operators.emplace_back(op35, xnn_delete_operator);
1190
1191 xnn_operator_t op36 = nullptr;
1192 status = xnn_create_hardswish_nc_f16(
1193 240 /* channels */,
1194 240 /* input stride */,
1195 240 /* output stride */,
1196 0 /* flags */,
1197 &op36);
1198 if (status != xnn_status_success) {
1199 std::cerr << "failed to create operation #36" << std::endl;
1200 return ExecutionPlan();
1201 }
1202 operators.emplace_back(op36, xnn_delete_operator);
1203
1204 xnn_operator_t op37 = nullptr;
1205 status = xnn_create_convolution2d_nhwc_f16(
1206 0 /* top padding */, 1 /* right padding */,
1207 1 /* bottom padding */, 0 /* left padding */,
1208 3 /* kernel height */, 3 /* kernel width */,
1209 2 /* subsampling height */, 2 /* subsampling width */,
1210 1 /* dilation_height */, 1 /* dilation_width */,
1211 240 /* groups */,
1212 1 /* input channels per group */,
1213 1 /* output_channels_per_group */,
1214 240 /* input pixel stride */,
1215 240 /* output pixel stride */,
1216 w164.data(), w165.data(),
1217 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1218 0 /* flags */,
1219 &op37);
1220 if (status != xnn_status_success) {
1221 std::cerr << "failed to create operation #37" << std::endl;
1222 return ExecutionPlan();
1223 }
1224 operators.emplace_back(op37, xnn_delete_operator);
1225
1226 xnn_operator_t op38 = nullptr;
1227 status = xnn_create_hardswish_nc_f16(
1228 240 /* channels */,
1229 240 /* input stride */,
1230 240 /* output stride */,
1231 0 /* flags */,
1232 &op38);
1233 if (status != xnn_status_success) {
1234 std::cerr << "failed to create operation #38" << std::endl;
1235 return ExecutionPlan();
1236 }
1237 operators.emplace_back(op38, xnn_delete_operator);
1238
1239 xnn_operator_t op39 = nullptr;
1240 status = xnn_create_convolution2d_nhwc_f16(
1241 0 /* top padding */, 0 /* right padding */,
1242 0 /* bottom padding */, 0 /* left padding */,
1243 1 /* kernel height */, 1 /* kernel width */,
1244 1 /* subsampling height */, 1 /* subsampling width */,
1245 1 /* dilation_height */, 1 /* dilation_width */,
1246 1 /* groups */,
1247 240 /* input channels per group */,
1248 80 /* output_channels_per_group */,
1249 240 /* input pixel stride */,
1250 80 /* output pixel stride */,
1251 w166.data(), w167.data(),
1252 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1253 0 /* flags */,
1254 &op39);
1255 if (status != xnn_status_success) {
1256 std::cerr << "failed to create operation #39" << std::endl;
1257 return ExecutionPlan();
1258 }
1259 operators.emplace_back(op39, xnn_delete_operator);
1260
1261 xnn_operator_t op40 = nullptr;
1262 status = xnn_create_convolution2d_nhwc_f16(
1263 0 /* top padding */, 0 /* right padding */,
1264 0 /* bottom padding */, 0 /* left padding */,
1265 1 /* kernel height */, 1 /* kernel width */,
1266 1 /* subsampling height */, 1 /* subsampling width */,
1267 1 /* dilation_height */, 1 /* dilation_width */,
1268 1 /* groups */,
1269 80 /* input channels per group */,
1270 200 /* output_channels_per_group */,
1271 80 /* input pixel stride */,
1272 200 /* output pixel stride */,
1273 w168.data(), w169.data(),
1274 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1275 0 /* flags */,
1276 &op40);
1277 if (status != xnn_status_success) {
1278 std::cerr << "failed to create operation #40" << std::endl;
1279 return ExecutionPlan();
1280 }
1281 operators.emplace_back(op40, xnn_delete_operator);
1282
1283 xnn_operator_t op41 = nullptr;
1284 status = xnn_create_hardswish_nc_f16(
1285 200 /* channels */,
1286 200 /* input stride */,
1287 200 /* output stride */,
1288 0 /* flags */,
1289 &op41);
1290 if (status != xnn_status_success) {
1291 std::cerr << "failed to create operation #41" << std::endl;
1292 return ExecutionPlan();
1293 }
1294 operators.emplace_back(op41, xnn_delete_operator);
1295
1296 xnn_operator_t op42 = nullptr;
1297 status = xnn_create_convolution2d_nhwc_f16(
1298 1 /* top padding */, 1 /* right padding */,
1299 1 /* bottom padding */, 1 /* left padding */,
1300 3 /* kernel height */, 3 /* kernel width */,
1301 1 /* subsampling height */, 1 /* subsampling width */,
1302 1 /* dilation_height */, 1 /* dilation_width */,
1303 200 /* groups */,
1304 1 /* input channels per group */,
1305 1 /* output_channels_per_group */,
1306 200 /* input pixel stride */,
1307 200 /* output pixel stride */,
1308 w170.data(), w171.data(),
1309 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1310 0 /* flags */,
1311 &op42);
1312 if (status != xnn_status_success) {
1313 std::cerr << "failed to create operation #42" << std::endl;
1314 return ExecutionPlan();
1315 }
1316 operators.emplace_back(op42, xnn_delete_operator);
1317
1318 xnn_operator_t op43 = nullptr;
1319 status = xnn_create_hardswish_nc_f16(
1320 200 /* channels */,
1321 200 /* input stride */,
1322 200 /* output stride */,
1323 0 /* flags */,
1324 &op43);
1325 if (status != xnn_status_success) {
1326 std::cerr << "failed to create operation #43" << std::endl;
1327 return ExecutionPlan();
1328 }
1329 operators.emplace_back(op43, xnn_delete_operator);
1330
1331 xnn_operator_t op44 = nullptr;
1332 status = xnn_create_convolution2d_nhwc_f16(
1333 0 /* top padding */, 0 /* right padding */,
1334 0 /* bottom padding */, 0 /* left padding */,
1335 1 /* kernel height */, 1 /* kernel width */,
1336 1 /* subsampling height */, 1 /* subsampling width */,
1337 1 /* dilation_height */, 1 /* dilation_width */,
1338 1 /* groups */,
1339 200 /* input channels per group */,
1340 80 /* output_channels_per_group */,
1341 200 /* input pixel stride */,
1342 80 /* output pixel stride */,
1343 w172.data(), w173.data(),
1344 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1345 0 /* flags */,
1346 &op44);
1347 if (status != xnn_status_success) {
1348 std::cerr << "failed to create operation #44" << std::endl;
1349 return ExecutionPlan();
1350 }
1351 operators.emplace_back(op44, xnn_delete_operator);
1352
1353 xnn_operator_t op45 = nullptr;
1354 status = xnn_create_add_nd_f16(
1355 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1356 0 /* flags */,
1357 &op45);
1358 if (status != xnn_status_success) {
1359 std::cerr << "failed to create operation #45" << std::endl;
1360 return ExecutionPlan();
1361 }
1362 operators.emplace_back(op45, xnn_delete_operator);
1363
1364 xnn_operator_t op46 = nullptr;
1365 status = xnn_create_convolution2d_nhwc_f16(
1366 0 /* top padding */, 0 /* right padding */,
1367 0 /* bottom padding */, 0 /* left padding */,
1368 1 /* kernel height */, 1 /* kernel width */,
1369 1 /* subsampling height */, 1 /* subsampling width */,
1370 1 /* dilation_height */, 1 /* dilation_width */,
1371 1 /* groups */,
1372 80 /* input channels per group */,
1373 184 /* output_channels_per_group */,
1374 80 /* input pixel stride */,
1375 184 /* output pixel stride */,
1376 w174.data(), w175.data(),
1377 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1378 0 /* flags */,
1379 &op46);
1380 if (status != xnn_status_success) {
1381 std::cerr << "failed to create operation #46" << std::endl;
1382 return ExecutionPlan();
1383 }
1384 operators.emplace_back(op46, xnn_delete_operator);
1385
1386 xnn_operator_t op47 = nullptr;
1387 status = xnn_create_hardswish_nc_f16(
1388 184 /* channels */,
1389 184 /* input stride */,
1390 184 /* output stride */,
1391 0 /* flags */,
1392 &op47);
1393 if (status != xnn_status_success) {
1394 std::cerr << "failed to create operation #47" << std::endl;
1395 return ExecutionPlan();
1396 }
1397 operators.emplace_back(op47, xnn_delete_operator);
1398
1399 xnn_operator_t op48 = nullptr;
1400 status = xnn_create_convolution2d_nhwc_f16(
1401 1 /* top padding */, 1 /* right padding */,
1402 1 /* bottom padding */, 1 /* left padding */,
1403 3 /* kernel height */, 3 /* kernel width */,
1404 1 /* subsampling height */, 1 /* subsampling width */,
1405 1 /* dilation_height */, 1 /* dilation_width */,
1406 184 /* groups */,
1407 1 /* input channels per group */,
1408 1 /* output_channels_per_group */,
1409 184 /* input pixel stride */,
1410 184 /* output pixel stride */,
1411 w176.data(), w177.data(),
1412 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1413 0 /* flags */,
1414 &op48);
1415 if (status != xnn_status_success) {
1416 std::cerr << "failed to create operation #48" << std::endl;
1417 return ExecutionPlan();
1418 }
1419 operators.emplace_back(op48, xnn_delete_operator);
1420
1421 xnn_operator_t op49 = nullptr;
1422 status = xnn_create_hardswish_nc_f16(
1423 184 /* channels */,
1424 184 /* input stride */,
1425 184 /* output stride */,
1426 0 /* flags */,
1427 &op49);
1428 if (status != xnn_status_success) {
1429 std::cerr << "failed to create operation #49" << std::endl;
1430 return ExecutionPlan();
1431 }
1432 operators.emplace_back(op49, xnn_delete_operator);
1433
1434 xnn_operator_t op50 = nullptr;
1435 status = xnn_create_convolution2d_nhwc_f16(
1436 0 /* top padding */, 0 /* right padding */,
1437 0 /* bottom padding */, 0 /* left padding */,
1438 1 /* kernel height */, 1 /* kernel width */,
1439 1 /* subsampling height */, 1 /* subsampling width */,
1440 1 /* dilation_height */, 1 /* dilation_width */,
1441 1 /* groups */,
1442 184 /* input channels per group */,
1443 80 /* output_channels_per_group */,
1444 184 /* input pixel stride */,
1445 80 /* output pixel stride */,
1446 w178.data(), w179.data(),
1447 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1448 0 /* flags */,
1449 &op50);
1450 if (status != xnn_status_success) {
1451 std::cerr << "failed to create operation #50" << std::endl;
1452 return ExecutionPlan();
1453 }
1454 operators.emplace_back(op50, xnn_delete_operator);
1455
1456 xnn_operator_t op51 = nullptr;
1457 status = xnn_create_add_nd_f16(
1458 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1459 0 /* flags */,
1460 &op51);
1461 if (status != xnn_status_success) {
1462 std::cerr << "failed to create operation #51" << std::endl;
1463 return ExecutionPlan();
1464 }
1465 operators.emplace_back(op51, xnn_delete_operator);
1466
1467 xnn_operator_t op52 = nullptr;
1468 status = xnn_create_convolution2d_nhwc_f16(
1469 0 /* top padding */, 0 /* right padding */,
1470 0 /* bottom padding */, 0 /* left padding */,
1471 1 /* kernel height */, 1 /* kernel width */,
1472 1 /* subsampling height */, 1 /* subsampling width */,
1473 1 /* dilation_height */, 1 /* dilation_width */,
1474 1 /* groups */,
1475 80 /* input channels per group */,
1476 184 /* output_channels_per_group */,
1477 80 /* input pixel stride */,
1478 184 /* output pixel stride */,
1479 w180.data(), w181.data(),
1480 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1481 0 /* flags */,
1482 &op52);
1483 if (status != xnn_status_success) {
1484 std::cerr << "failed to create operation #52" << std::endl;
1485 return ExecutionPlan();
1486 }
1487 operators.emplace_back(op52, xnn_delete_operator);
1488
1489 xnn_operator_t op53 = nullptr;
1490 status = xnn_create_hardswish_nc_f16(
1491 184 /* channels */,
1492 184 /* input stride */,
1493 184 /* output stride */,
1494 0 /* flags */,
1495 &op53);
1496 if (status != xnn_status_success) {
1497 std::cerr << "failed to create operation #53" << std::endl;
1498 return ExecutionPlan();
1499 }
1500 operators.emplace_back(op53, xnn_delete_operator);
1501
1502 xnn_operator_t op54 = nullptr;
1503 status = xnn_create_convolution2d_nhwc_f16(
1504 1 /* top padding */, 1 /* right padding */,
1505 1 /* bottom padding */, 1 /* left padding */,
1506 3 /* kernel height */, 3 /* kernel width */,
1507 1 /* subsampling height */, 1 /* subsampling width */,
1508 1 /* dilation_height */, 1 /* dilation_width */,
1509 184 /* groups */,
1510 1 /* input channels per group */,
1511 1 /* output_channels_per_group */,
1512 184 /* input pixel stride */,
1513 184 /* output pixel stride */,
1514 w182.data(), w183.data(),
1515 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1516 0 /* flags */,
1517 &op54);
1518 if (status != xnn_status_success) {
1519 std::cerr << "failed to create operation #54" << std::endl;
1520 return ExecutionPlan();
1521 }
1522 operators.emplace_back(op54, xnn_delete_operator);
1523
1524 xnn_operator_t op55 = nullptr;
1525 status = xnn_create_hardswish_nc_f16(
1526 184 /* channels */,
1527 184 /* input stride */,
1528 184 /* output stride */,
1529 0 /* flags */,
1530 &op55);
1531 if (status != xnn_status_success) {
1532 std::cerr << "failed to create operation #55" << std::endl;
1533 return ExecutionPlan();
1534 }
1535 operators.emplace_back(op55, xnn_delete_operator);
1536
1537 xnn_operator_t op56 = nullptr;
1538 status = xnn_create_convolution2d_nhwc_f16(
1539 0 /* top padding */, 0 /* right padding */,
1540 0 /* bottom padding */, 0 /* left padding */,
1541 1 /* kernel height */, 1 /* kernel width */,
1542 1 /* subsampling height */, 1 /* subsampling width */,
1543 1 /* dilation_height */, 1 /* dilation_width */,
1544 1 /* groups */,
1545 184 /* input channels per group */,
1546 80 /* output_channels_per_group */,
1547 184 /* input pixel stride */,
1548 80 /* output pixel stride */,
1549 w184.data(), w185.data(),
1550 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1551 0 /* flags */,
1552 &op56);
1553 if (status != xnn_status_success) {
1554 std::cerr << "failed to create operation #56" << std::endl;
1555 return ExecutionPlan();
1556 }
1557 operators.emplace_back(op56, xnn_delete_operator);
1558
1559 xnn_operator_t op57 = nullptr;
1560 status = xnn_create_add_nd_f16(
1561 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1562 0 /* flags */,
1563 &op57);
1564 if (status != xnn_status_success) {
1565 std::cerr << "failed to create operation #57" << std::endl;
1566 return ExecutionPlan();
1567 }
1568 operators.emplace_back(op57, xnn_delete_operator);
1569
1570 xnn_operator_t op58 = nullptr;
1571 status = xnn_create_convolution2d_nhwc_f16(
1572 0 /* top padding */, 0 /* right padding */,
1573 0 /* bottom padding */, 0 /* left padding */,
1574 1 /* kernel height */, 1 /* kernel width */,
1575 1 /* subsampling height */, 1 /* subsampling width */,
1576 1 /* dilation_height */, 1 /* dilation_width */,
1577 1 /* groups */,
1578 80 /* input channels per group */,
1579 480 /* output_channels_per_group */,
1580 80 /* input pixel stride */,
1581 480 /* output pixel stride */,
1582 w186.data(), w187.data(),
1583 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1584 0 /* flags */,
1585 &op58);
1586 if (status != xnn_status_success) {
1587 std::cerr << "failed to create operation #58" << std::endl;
1588 return ExecutionPlan();
1589 }
1590 operators.emplace_back(op58, xnn_delete_operator);
1591
1592 xnn_operator_t op59 = nullptr;
1593 status = xnn_create_hardswish_nc_f16(
1594 480 /* channels */,
1595 480 /* input stride */,
1596 480 /* output stride */,
1597 0 /* flags */,
1598 &op59);
1599 if (status != xnn_status_success) {
1600 std::cerr << "failed to create operation #59" << std::endl;
1601 return ExecutionPlan();
1602 }
1603 operators.emplace_back(op59, xnn_delete_operator);
1604
1605 xnn_operator_t op60 = nullptr;
1606 status = xnn_create_convolution2d_nhwc_f16(
1607 1 /* top padding */, 1 /* right padding */,
1608 1 /* bottom padding */, 1 /* left padding */,
1609 3 /* kernel height */, 3 /* kernel width */,
1610 1 /* subsampling height */, 1 /* subsampling width */,
1611 1 /* dilation_height */, 1 /* dilation_width */,
1612 480 /* groups */,
1613 1 /* input channels per group */,
1614 1 /* output_channels_per_group */,
1615 480 /* input pixel stride */,
1616 480 /* output pixel stride */,
1617 w188.data(), w189.data(),
1618 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1619 0 /* flags */,
1620 &op60);
1621 if (status != xnn_status_success) {
1622 std::cerr << "failed to create operation #60" << std::endl;
1623 return ExecutionPlan();
1624 }
1625 operators.emplace_back(op60, xnn_delete_operator);
1626
1627 xnn_operator_t op61 = nullptr;
1628 status = xnn_create_hardswish_nc_f16(
1629 480 /* channels */,
1630 480 /* input stride */,
1631 480 /* output stride */,
1632 0 /* flags */,
1633 &op61);
1634 if (status != xnn_status_success) {
1635 std::cerr << "failed to create operation #61" << std::endl;
1636 return ExecutionPlan();
1637 }
1638 operators.emplace_back(op61, xnn_delete_operator);
1639
1640 xnn_operator_t op62 = nullptr;
1641 status = xnn_create_global_average_pooling_nwc_f16(
1642 480 /* channels */, 480 /* input stride */, 480 /* output stride */,
1643 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1644 0 /* flags */,
1645 &op62);
1646 if (status != xnn_status_success) {
1647 std::cerr << "failed to create operation #62" << std::endl;
1648 return ExecutionPlan();
1649 }
1650 operators.emplace_back(op62, xnn_delete_operator);
1651
1652 xnn_operator_t op63 = nullptr;
1653 status = xnn_create_convolution2d_nhwc_f16(
1654 0 /* top padding */, 0 /* right padding */,
1655 0 /* bottom padding */, 0 /* left padding */,
1656 1 /* kernel height */, 1 /* kernel width */,
1657 1 /* subsampling height */, 1 /* subsampling width */,
1658 1 /* dilation_height */, 1 /* dilation_width */,
1659 1 /* groups */,
1660 480 /* input channels per group */,
1661 120 /* output_channels_per_group */,
1662 480 /* input pixel stride */,
1663 120 /* output pixel stride */,
1664 w190.data(), w191.data(),
1665 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1666 0 /* flags */,
1667 &op63);
1668 if (status != xnn_status_success) {
1669 std::cerr << "failed to create operation #63" << std::endl;
1670 return ExecutionPlan();
1671 }
1672 operators.emplace_back(op63, xnn_delete_operator);
1673
1674 xnn_operator_t op64 = nullptr;
1675 status = xnn_create_convolution2d_nhwc_f16(
1676 0 /* top padding */, 0 /* right padding */,
1677 0 /* bottom padding */, 0 /* left padding */,
1678 1 /* kernel height */, 1 /* kernel width */,
1679 1 /* subsampling height */, 1 /* subsampling width */,
1680 1 /* dilation_height */, 1 /* dilation_width */,
1681 1 /* groups */,
1682 120 /* input channels per group */,
1683 480 /* output_channels_per_group */,
1684 120 /* input pixel stride */,
1685 480 /* output pixel stride */,
1686 w192.data(), w193.data(),
1687 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
1688 0 /* flags */,
1689 &op64);
1690 if (status != xnn_status_success) {
1691 std::cerr << "failed to create operation #64" << std::endl;
1692 return ExecutionPlan();
1693 }
1694 operators.emplace_back(op64, xnn_delete_operator);
1695
1696 xnn_operator_t op65 = nullptr;
1697 status = xnn_create_multiply_nd_f16(
1698 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1699 0 /* flags */,
1700 &op65);
1701 if (status != xnn_status_success) {
1702 std::cerr << "failed to create operation #65" << std::endl;
1703 return ExecutionPlan();
1704 }
1705 operators.emplace_back(op65, xnn_delete_operator);
1706
1707 xnn_operator_t op66 = nullptr;
1708 status = xnn_create_convolution2d_nhwc_f16(
1709 0 /* top padding */, 0 /* right padding */,
1710 0 /* bottom padding */, 0 /* left padding */,
1711 1 /* kernel height */, 1 /* kernel width */,
1712 1 /* subsampling height */, 1 /* subsampling width */,
1713 1 /* dilation_height */, 1 /* dilation_width */,
1714 1 /* groups */,
1715 480 /* input channels per group */,
1716 112 /* output_channels_per_group */,
1717 480 /* input pixel stride */,
1718 112 /* output pixel stride */,
1719 w194.data(), w195.data(),
1720 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1721 0 /* flags */,
1722 &op66);
1723 if (status != xnn_status_success) {
1724 std::cerr << "failed to create operation #66" << std::endl;
1725 return ExecutionPlan();
1726 }
1727 operators.emplace_back(op66, xnn_delete_operator);
1728
1729 xnn_operator_t op67 = nullptr;
1730 status = xnn_create_convolution2d_nhwc_f16(
1731 0 /* top padding */, 0 /* right padding */,
1732 0 /* bottom padding */, 0 /* left padding */,
1733 1 /* kernel height */, 1 /* kernel width */,
1734 1 /* subsampling height */, 1 /* subsampling width */,
1735 1 /* dilation_height */, 1 /* dilation_width */,
1736 1 /* groups */,
1737 112 /* input channels per group */,
1738 672 /* output_channels_per_group */,
1739 112 /* input pixel stride */,
1740 672 /* output pixel stride */,
1741 w196.data(), w197.data(),
1742 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1743 0 /* flags */,
1744 &op67);
1745 if (status != xnn_status_success) {
1746 std::cerr << "failed to create operation #67" << std::endl;
1747 return ExecutionPlan();
1748 }
1749 operators.emplace_back(op67, xnn_delete_operator);
1750
1751 xnn_operator_t op68 = nullptr;
1752 status = xnn_create_hardswish_nc_f16(
1753 672 /* channels */,
1754 672 /* input stride */,
1755 672 /* output stride */,
1756 0 /* flags */,
1757 &op68);
1758 if (status != xnn_status_success) {
1759 std::cerr << "failed to create operation #68" << std::endl;
1760 return ExecutionPlan();
1761 }
1762 operators.emplace_back(op68, xnn_delete_operator);
1763
1764 xnn_operator_t op69 = nullptr;
1765 status = xnn_create_convolution2d_nhwc_f16(
1766 1 /* top padding */, 1 /* right padding */,
1767 1 /* bottom padding */, 1 /* left padding */,
1768 3 /* kernel height */, 3 /* kernel width */,
1769 1 /* subsampling height */, 1 /* subsampling width */,
1770 1 /* dilation_height */, 1 /* dilation_width */,
1771 672 /* groups */,
1772 1 /* input channels per group */,
1773 1 /* output_channels_per_group */,
1774 672 /* input pixel stride */,
1775 672 /* output pixel stride */,
1776 w198.data(), w199.data(),
1777 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1778 0 /* flags */,
1779 &op69);
1780 if (status != xnn_status_success) {
1781 std::cerr << "failed to create operation #69" << std::endl;
1782 return ExecutionPlan();
1783 }
1784 operators.emplace_back(op69, xnn_delete_operator);
1785
1786 xnn_operator_t op70 = nullptr;
1787 status = xnn_create_hardswish_nc_f16(
1788 672 /* channels */,
1789 672 /* input stride */,
1790 672 /* output stride */,
1791 0 /* flags */,
1792 &op70);
1793 if (status != xnn_status_success) {
1794 std::cerr << "failed to create operation #70" << std::endl;
1795 return ExecutionPlan();
1796 }
1797 operators.emplace_back(op70, xnn_delete_operator);
1798
1799 xnn_operator_t op71 = nullptr;
1800 status = xnn_create_global_average_pooling_nwc_f16(
1801 672 /* channels */, 672 /* input stride */, 672 /* output stride */,
1802 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1803 0 /* flags */,
1804 &op71);
1805 if (status != xnn_status_success) {
1806 std::cerr << "failed to create operation #71" << std::endl;
1807 return ExecutionPlan();
1808 }
1809 operators.emplace_back(op71, xnn_delete_operator);
1810
1811 xnn_operator_t op72 = nullptr;
1812 status = xnn_create_convolution2d_nhwc_f16(
1813 0 /* top padding */, 0 /* right padding */,
1814 0 /* bottom padding */, 0 /* left padding */,
1815 1 /* kernel height */, 1 /* kernel width */,
1816 1 /* subsampling height */, 1 /* subsampling width */,
1817 1 /* dilation_height */, 1 /* dilation_width */,
1818 1 /* groups */,
1819 672 /* input channels per group */,
1820 168 /* output_channels_per_group */,
1821 672 /* input pixel stride */,
1822 168 /* output pixel stride */,
1823 w200.data(), w201.data(),
1824 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1825 0 /* flags */,
1826 &op72);
1827 if (status != xnn_status_success) {
1828 std::cerr << "failed to create operation #72" << std::endl;
1829 return ExecutionPlan();
1830 }
1831 operators.emplace_back(op72, xnn_delete_operator);
1832
1833 xnn_operator_t op73 = nullptr;
1834 status = xnn_create_convolution2d_nhwc_f16(
1835 0 /* top padding */, 0 /* right padding */,
1836 0 /* bottom padding */, 0 /* left padding */,
1837 1 /* kernel height */, 1 /* kernel width */,
1838 1 /* subsampling height */, 1 /* subsampling width */,
1839 1 /* dilation_height */, 1 /* dilation_width */,
1840 1 /* groups */,
1841 168 /* input channels per group */,
1842 672 /* output_channels_per_group */,
1843 168 /* input pixel stride */,
1844 672 /* output pixel stride */,
1845 w202.data(), w203.data(),
1846 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
1847 0 /* flags */,
1848 &op73);
1849 if (status != xnn_status_success) {
1850 std::cerr << "failed to create operation #73" << std::endl;
1851 return ExecutionPlan();
1852 }
1853 operators.emplace_back(op73, xnn_delete_operator);
1854
1855 xnn_operator_t op74 = nullptr;
1856 status = xnn_create_multiply_nd_f16(
1857 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1858 0 /* flags */,
1859 &op74);
1860 if (status != xnn_status_success) {
1861 std::cerr << "failed to create operation #74" << std::endl;
1862 return ExecutionPlan();
1863 }
1864 operators.emplace_back(op74, xnn_delete_operator);
1865
1866 xnn_operator_t op75 = nullptr;
1867 status = xnn_create_convolution2d_nhwc_f16(
1868 0 /* top padding */, 0 /* right padding */,
1869 0 /* bottom padding */, 0 /* left padding */,
1870 1 /* kernel height */, 1 /* kernel width */,
1871 1 /* subsampling height */, 1 /* subsampling width */,
1872 1 /* dilation_height */, 1 /* dilation_width */,
1873 1 /* groups */,
1874 672 /* input channels per group */,
1875 112 /* output_channels_per_group */,
1876 672 /* input pixel stride */,
1877 112 /* output pixel stride */,
1878 w204.data(), w205.data(),
1879 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1880 0 /* flags */,
1881 &op75);
1882 if (status != xnn_status_success) {
1883 std::cerr << "failed to create operation #75" << std::endl;
1884 return ExecutionPlan();
1885 }
1886 operators.emplace_back(op75, xnn_delete_operator);
1887
1888 xnn_operator_t op76 = nullptr;
1889 status = xnn_create_add_nd_f16(
1890 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1891 0 /* flags */,
1892 &op76);
1893 if (status != xnn_status_success) {
1894 std::cerr << "failed to create operation #76" << std::endl;
1895 return ExecutionPlan();
1896 }
1897 operators.emplace_back(op76, xnn_delete_operator);
1898
1899 xnn_operator_t op77 = nullptr;
1900 status = xnn_create_convolution2d_nhwc_f16(
1901 0 /* top padding */, 0 /* right padding */,
1902 0 /* bottom padding */, 0 /* left padding */,
1903 1 /* kernel height */, 1 /* kernel width */,
1904 1 /* subsampling height */, 1 /* subsampling width */,
1905 1 /* dilation_height */, 1 /* dilation_width */,
1906 1 /* groups */,
1907 112 /* input channels per group */,
1908 672 /* output_channels_per_group */,
1909 112 /* input pixel stride */,
1910 672 /* output pixel stride */,
1911 w206.data(), w207.data(),
1912 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1913 0 /* flags */,
1914 &op77);
1915 if (status != xnn_status_success) {
1916 std::cerr << "failed to create operation #77" << std::endl;
1917 return ExecutionPlan();
1918 }
1919 operators.emplace_back(op77, xnn_delete_operator);
1920
1921 xnn_operator_t op78 = nullptr;
1922 status = xnn_create_hardswish_nc_f16(
1923 672 /* channels */,
1924 672 /* input stride */,
1925 672 /* output stride */,
1926 0 /* flags */,
1927 &op78);
1928 if (status != xnn_status_success) {
1929 std::cerr << "failed to create operation #78" << std::endl;
1930 return ExecutionPlan();
1931 }
1932 operators.emplace_back(op78, xnn_delete_operator);
1933
1934 xnn_operator_t op79 = nullptr;
1935 status = xnn_create_convolution2d_nhwc_f16(
1936 1 /* top padding */, 2 /* right padding */,
1937 2 /* bottom padding */, 1 /* left padding */,
1938 5 /* kernel height */, 5 /* kernel width */,
1939 2 /* subsampling height */, 2 /* subsampling width */,
1940 1 /* dilation_height */, 1 /* dilation_width */,
1941 672 /* groups */,
1942 1 /* input channels per group */,
1943 1 /* output_channels_per_group */,
1944 672 /* input pixel stride */,
1945 672 /* output pixel stride */,
1946 w208.data(), w209.data(),
1947 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1948 0 /* flags */,
1949 &op79);
1950 if (status != xnn_status_success) {
1951 std::cerr << "failed to create operation #79" << std::endl;
1952 return ExecutionPlan();
1953 }
1954 operators.emplace_back(op79, xnn_delete_operator);
1955
1956 xnn_operator_t op80 = nullptr;
1957 status = xnn_create_hardswish_nc_f16(
1958 672 /* channels */,
1959 672 /* input stride */,
1960 672 /* output stride */,
1961 0 /* flags */,
1962 &op80);
1963 if (status != xnn_status_success) {
1964 std::cerr << "failed to create operation #80" << std::endl;
1965 return ExecutionPlan();
1966 }
1967 operators.emplace_back(op80, xnn_delete_operator);
1968
1969 xnn_operator_t op81 = nullptr;
1970 status = xnn_create_global_average_pooling_nwc_f16(
1971 672 /* channels */, 672 /* input stride */, 672 /* output stride */,
1972 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1973 0 /* flags */,
1974 &op81);
1975 if (status != xnn_status_success) {
1976 std::cerr << "failed to create operation #81" << std::endl;
1977 return ExecutionPlan();
1978 }
1979 operators.emplace_back(op81, xnn_delete_operator);
1980
1981 xnn_operator_t op82 = nullptr;
1982 status = xnn_create_convolution2d_nhwc_f16(
1983 0 /* top padding */, 0 /* right padding */,
1984 0 /* bottom padding */, 0 /* left padding */,
1985 1 /* kernel height */, 1 /* kernel width */,
1986 1 /* subsampling height */, 1 /* subsampling width */,
1987 1 /* dilation_height */, 1 /* dilation_width */,
1988 1 /* groups */,
1989 672 /* input channels per group */,
1990 168 /* output_channels_per_group */,
1991 672 /* input pixel stride */,
1992 168 /* output pixel stride */,
1993 w210.data(), w211.data(),
1994 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1995 0 /* flags */,
1996 &op82);
1997 if (status != xnn_status_success) {
1998 std::cerr << "failed to create operation #82" << std::endl;
1999 return ExecutionPlan();
2000 }
2001 operators.emplace_back(op82, xnn_delete_operator);
2002
2003 xnn_operator_t op83 = nullptr;
2004 status = xnn_create_convolution2d_nhwc_f16(
2005 0 /* top padding */, 0 /* right padding */,
2006 0 /* bottom padding */, 0 /* left padding */,
2007 1 /* kernel height */, 1 /* kernel width */,
2008 1 /* subsampling height */, 1 /* subsampling width */,
2009 1 /* dilation_height */, 1 /* dilation_width */,
2010 1 /* groups */,
2011 168 /* input channels per group */,
2012 672 /* output_channels_per_group */,
2013 168 /* input pixel stride */,
2014 672 /* output pixel stride */,
2015 w212.data(), w213.data(),
2016 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
2017 0 /* flags */,
2018 &op83);
2019 if (status != xnn_status_success) {
2020 std::cerr << "failed to create operation #83" << std::endl;
2021 return ExecutionPlan();
2022 }
2023 operators.emplace_back(op83, xnn_delete_operator);
2024
2025 xnn_operator_t op84 = nullptr;
2026 status = xnn_create_multiply_nd_f16(
2027 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2028 0 /* flags */,
2029 &op84);
2030 if (status != xnn_status_success) {
2031 std::cerr << "failed to create operation #84" << std::endl;
2032 return ExecutionPlan();
2033 }
2034 operators.emplace_back(op84, xnn_delete_operator);
2035
2036 xnn_operator_t op85 = nullptr;
2037 status = xnn_create_convolution2d_nhwc_f16(
2038 0 /* top padding */, 0 /* right padding */,
2039 0 /* bottom padding */, 0 /* left padding */,
2040 1 /* kernel height */, 1 /* kernel width */,
2041 1 /* subsampling height */, 1 /* subsampling width */,
2042 1 /* dilation_height */, 1 /* dilation_width */,
2043 1 /* groups */,
2044 672 /* input channels per group */,
2045 160 /* output_channels_per_group */,
2046 672 /* input pixel stride */,
2047 160 /* output pixel stride */,
2048 w214.data(), w215.data(),
2049 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2050 0 /* flags */,
2051 &op85);
2052 if (status != xnn_status_success) {
2053 std::cerr << "failed to create operation #85" << std::endl;
2054 return ExecutionPlan();
2055 }
2056 operators.emplace_back(op85, xnn_delete_operator);
2057
2058 xnn_operator_t op86 = nullptr;
2059 status = xnn_create_convolution2d_nhwc_f16(
2060 0 /* top padding */, 0 /* right padding */,
2061 0 /* bottom padding */, 0 /* left padding */,
2062 1 /* kernel height */, 1 /* kernel width */,
2063 1 /* subsampling height */, 1 /* subsampling width */,
2064 1 /* dilation_height */, 1 /* dilation_width */,
2065 1 /* groups */,
2066 160 /* input channels per group */,
2067 960 /* output_channels_per_group */,
2068 160 /* input pixel stride */,
2069 960 /* output pixel stride */,
2070 w216.data(), w217.data(),
2071 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2072 0 /* flags */,
2073 &op86);
2074 if (status != xnn_status_success) {
2075 std::cerr << "failed to create operation #86" << std::endl;
2076 return ExecutionPlan();
2077 }
2078 operators.emplace_back(op86, xnn_delete_operator);
2079
2080 xnn_operator_t op87 = nullptr;
2081 status = xnn_create_hardswish_nc_f16(
2082 960 /* channels */,
2083 960 /* input stride */,
2084 960 /* output stride */,
2085 0 /* flags */,
2086 &op87);
2087 if (status != xnn_status_success) {
2088 std::cerr << "failed to create operation #87" << std::endl;
2089 return ExecutionPlan();
2090 }
2091 operators.emplace_back(op87, xnn_delete_operator);
2092
2093 xnn_operator_t op88 = nullptr;
2094 status = xnn_create_convolution2d_nhwc_f16(
2095 2 /* top padding */, 2 /* right padding */,
2096 2 /* bottom padding */, 2 /* left padding */,
2097 5 /* kernel height */, 5 /* kernel width */,
2098 1 /* subsampling height */, 1 /* subsampling width */,
2099 1 /* dilation_height */, 1 /* dilation_width */,
2100 960 /* groups */,
2101 1 /* input channels per group */,
2102 1 /* output_channels_per_group */,
2103 960 /* input pixel stride */,
2104 960 /* output pixel stride */,
2105 w218.data(), w219.data(),
2106 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2107 0 /* flags */,
2108 &op88);
2109 if (status != xnn_status_success) {
2110 std::cerr << "failed to create operation #88" << std::endl;
2111 return ExecutionPlan();
2112 }
2113 operators.emplace_back(op88, xnn_delete_operator);
2114
2115 xnn_operator_t op89 = nullptr;
2116 status = xnn_create_hardswish_nc_f16(
2117 960 /* channels */,
2118 960 /* input stride */,
2119 960 /* output stride */,
2120 0 /* flags */,
2121 &op89);
2122 if (status != xnn_status_success) {
2123 std::cerr << "failed to create operation #89" << std::endl;
2124 return ExecutionPlan();
2125 }
2126 operators.emplace_back(op89, xnn_delete_operator);
2127
2128 xnn_operator_t op90 = nullptr;
2129 status = xnn_create_global_average_pooling_nwc_f16(
2130 960 /* channels */, 960 /* input stride */, 960 /* output stride */,
2131 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2132 0 /* flags */,
2133 &op90);
2134 if (status != xnn_status_success) {
2135 std::cerr << "failed to create operation #90" << std::endl;
2136 return ExecutionPlan();
2137 }
2138 operators.emplace_back(op90, xnn_delete_operator);
2139
2140 xnn_operator_t op91 = nullptr;
2141 status = xnn_create_convolution2d_nhwc_f16(
2142 0 /* top padding */, 0 /* right padding */,
2143 0 /* bottom padding */, 0 /* left padding */,
2144 1 /* kernel height */, 1 /* kernel width */,
2145 1 /* subsampling height */, 1 /* subsampling width */,
2146 1 /* dilation_height */, 1 /* dilation_width */,
2147 1 /* groups */,
2148 960 /* input channels per group */,
2149 240 /* output_channels_per_group */,
2150 960 /* input pixel stride */,
2151 240 /* output pixel stride */,
2152 w220.data(), w221.data(),
2153 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2154 0 /* flags */,
2155 &op91);
2156 if (status != xnn_status_success) {
2157 std::cerr << "failed to create operation #91" << std::endl;
2158 return ExecutionPlan();
2159 }
2160 operators.emplace_back(op91, xnn_delete_operator);
2161
2162 xnn_operator_t op92 = nullptr;
2163 status = xnn_create_convolution2d_nhwc_f16(
2164 0 /* top padding */, 0 /* right padding */,
2165 0 /* bottom padding */, 0 /* left padding */,
2166 1 /* kernel height */, 1 /* kernel width */,
2167 1 /* subsampling height */, 1 /* subsampling width */,
2168 1 /* dilation_height */, 1 /* dilation_width */,
2169 1 /* groups */,
2170 240 /* input channels per group */,
2171 960 /* output_channels_per_group */,
2172 240 /* input pixel stride */,
2173 960 /* output pixel stride */,
2174 w222.data(), w223.data(),
2175 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
2176 0 /* flags */,
2177 &op92);
2178 if (status != xnn_status_success) {
2179 std::cerr << "failed to create operation #92" << std::endl;
2180 return ExecutionPlan();
2181 }
2182 operators.emplace_back(op92, xnn_delete_operator);
2183
2184 xnn_operator_t op93 = nullptr;
2185 status = xnn_create_multiply_nd_f16(
2186 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2187 0 /* flags */,
2188 &op93);
2189 if (status != xnn_status_success) {
2190 std::cerr << "failed to create operation #93" << std::endl;
2191 return ExecutionPlan();
2192 }
2193 operators.emplace_back(op93, xnn_delete_operator);
2194
2195 xnn_operator_t op94 = nullptr;
2196 status = xnn_create_convolution2d_nhwc_f16(
2197 0 /* top padding */, 0 /* right padding */,
2198 0 /* bottom padding */, 0 /* left padding */,
2199 1 /* kernel height */, 1 /* kernel width */,
2200 1 /* subsampling height */, 1 /* subsampling width */,
2201 1 /* dilation_height */, 1 /* dilation_width */,
2202 1 /* groups */,
2203 960 /* input channels per group */,
2204 160 /* output_channels_per_group */,
2205 960 /* input pixel stride */,
2206 160 /* output pixel stride */,
2207 w224.data(), w225.data(),
2208 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2209 0 /* flags */,
2210 &op94);
2211 if (status != xnn_status_success) {
2212 std::cerr << "failed to create operation #94" << std::endl;
2213 return ExecutionPlan();
2214 }
2215 operators.emplace_back(op94, xnn_delete_operator);
2216
2217 xnn_operator_t op95 = nullptr;
2218 status = xnn_create_add_nd_f16(
2219 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2220 0 /* flags */,
2221 &op95);
2222 if (status != xnn_status_success) {
2223 std::cerr << "failed to create operation #95" << std::endl;
2224 return ExecutionPlan();
2225 }
2226 operators.emplace_back(op95, xnn_delete_operator);
2227
2228 xnn_operator_t op96 = nullptr;
2229 status = xnn_create_convolution2d_nhwc_f16(
2230 0 /* top padding */, 0 /* right padding */,
2231 0 /* bottom padding */, 0 /* left padding */,
2232 1 /* kernel height */, 1 /* kernel width */,
2233 1 /* subsampling height */, 1 /* subsampling width */,
2234 1 /* dilation_height */, 1 /* dilation_width */,
2235 1 /* groups */,
2236 160 /* input channels per group */,
2237 960 /* output_channels_per_group */,
2238 160 /* input pixel stride */,
2239 960 /* output pixel stride */,
2240 w226.data(), w227.data(),
2241 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2242 0 /* flags */,
2243 &op96);
2244 if (status != xnn_status_success) {
2245 std::cerr << "failed to create operation #96" << std::endl;
2246 return ExecutionPlan();
2247 }
2248 operators.emplace_back(op96, xnn_delete_operator);
2249
2250 xnn_operator_t op97 = nullptr;
2251 status = xnn_create_hardswish_nc_f16(
2252 960 /* channels */,
2253 960 /* input stride */,
2254 960 /* output stride */,
2255 0 /* flags */,
2256 &op97);
2257 if (status != xnn_status_success) {
2258 std::cerr << "failed to create operation #97" << std::endl;
2259 return ExecutionPlan();
2260 }
2261 operators.emplace_back(op97, xnn_delete_operator);
2262
2263 xnn_operator_t op98 = nullptr;
2264 status = xnn_create_convolution2d_nhwc_f16(
2265 2 /* top padding */, 2 /* right padding */,
2266 2 /* bottom padding */, 2 /* left padding */,
2267 5 /* kernel height */, 5 /* kernel width */,
2268 1 /* subsampling height */, 1 /* subsampling width */,
2269 1 /* dilation_height */, 1 /* dilation_width */,
2270 960 /* groups */,
2271 1 /* input channels per group */,
2272 1 /* output_channels_per_group */,
2273 960 /* input pixel stride */,
2274 960 /* output pixel stride */,
2275 w228.data(), w229.data(),
2276 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2277 0 /* flags */,
2278 &op98);
2279 if (status != xnn_status_success) {
2280 std::cerr << "failed to create operation #98" << std::endl;
2281 return ExecutionPlan();
2282 }
2283 operators.emplace_back(op98, xnn_delete_operator);
2284
2285 xnn_operator_t op99 = nullptr;
2286 status = xnn_create_hardswish_nc_f16(
2287 960 /* channels */,
2288 960 /* input stride */,
2289 960 /* output stride */,
2290 0 /* flags */,
2291 &op99);
2292 if (status != xnn_status_success) {
2293 std::cerr << "failed to create operation #99" << std::endl;
2294 return ExecutionPlan();
2295 }
2296 operators.emplace_back(op99, xnn_delete_operator);
2297
2298 xnn_operator_t op100 = nullptr;
2299 status = xnn_create_global_average_pooling_nwc_f16(
2300 960 /* channels */, 960 /* input stride */, 960 /* output stride */,
2301 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2302 0 /* flags */,
2303 &op100);
2304 if (status != xnn_status_success) {
2305 std::cerr << "failed to create operation #100" << std::endl;
2306 return ExecutionPlan();
2307 }
2308 operators.emplace_back(op100, xnn_delete_operator);
2309
2310 xnn_operator_t op101 = nullptr;
2311 status = xnn_create_convolution2d_nhwc_f16(
2312 0 /* top padding */, 0 /* right padding */,
2313 0 /* bottom padding */, 0 /* left padding */,
2314 1 /* kernel height */, 1 /* kernel width */,
2315 1 /* subsampling height */, 1 /* subsampling width */,
2316 1 /* dilation_height */, 1 /* dilation_width */,
2317 1 /* groups */,
2318 960 /* input channels per group */,
2319 240 /* output_channels_per_group */,
2320 960 /* input pixel stride */,
2321 240 /* output pixel stride */,
2322 w230.data(), w231.data(),
2323 0.0f /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2324 0 /* flags */,
2325 &op101);
2326 if (status != xnn_status_success) {
2327 std::cerr << "failed to create operation #101" << std::endl;
2328 return ExecutionPlan();
2329 }
2330 operators.emplace_back(op101, xnn_delete_operator);
2331
2332 xnn_operator_t op102 = nullptr;
2333 status = xnn_create_convolution2d_nhwc_f16(
2334 0 /* top padding */, 0 /* right padding */,
2335 0 /* bottom padding */, 0 /* left padding */,
2336 1 /* kernel height */, 1 /* kernel width */,
2337 1 /* subsampling height */, 1 /* subsampling width */,
2338 1 /* dilation_height */, 1 /* dilation_width */,
2339 1 /* groups */,
2340 240 /* input channels per group */,
2341 960 /* output_channels_per_group */,
2342 240 /* input pixel stride */,
2343 960 /* output pixel stride */,
2344 w232.data(), w233.data(),
2345 0.0f /* output min */, +0x1.00014Fp+0 /* output max */,
2346 0 /* flags */,
2347 &op102);
2348 if (status != xnn_status_success) {
2349 std::cerr << "failed to create operation #102" << std::endl;
2350 return ExecutionPlan();
2351 }
2352 operators.emplace_back(op102, xnn_delete_operator);
2353
2354 xnn_operator_t op103 = nullptr;
2355 status = xnn_create_multiply_nd_f16(
2356 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2357 0 /* flags */,
2358 &op103);
2359 if (status != xnn_status_success) {
2360 std::cerr << "failed to create operation #103" << std::endl;
2361 return ExecutionPlan();
2362 }
2363 operators.emplace_back(op103, xnn_delete_operator);
2364
2365 xnn_operator_t op104 = nullptr;
2366 status = xnn_create_convolution2d_nhwc_f16(
2367 0 /* top padding */, 0 /* right padding */,
2368 0 /* bottom padding */, 0 /* left padding */,
2369 1 /* kernel height */, 1 /* kernel width */,
2370 1 /* subsampling height */, 1 /* subsampling width */,
2371 1 /* dilation_height */, 1 /* dilation_width */,
2372 1 /* groups */,
2373 960 /* input channels per group */,
2374 160 /* output_channels_per_group */,
2375 960 /* input pixel stride */,
2376 160 /* output pixel stride */,
2377 w234.data(), w235.data(),
2378 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2379 0 /* flags */,
2380 &op104);
2381 if (status != xnn_status_success) {
2382 std::cerr << "failed to create operation #104" << std::endl;
2383 return ExecutionPlan();
2384 }
2385 operators.emplace_back(op104, xnn_delete_operator);
2386
2387 xnn_operator_t op105 = nullptr;
2388 status = xnn_create_add_nd_f16(
2389 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2390 0 /* flags */,
2391 &op105);
2392 if (status != xnn_status_success) {
2393 std::cerr << "failed to create operation #105" << std::endl;
2394 return ExecutionPlan();
2395 }
2396 operators.emplace_back(op105, xnn_delete_operator);
2397
2398 xnn_operator_t op106 = nullptr;
2399 status = xnn_create_convolution2d_nhwc_f16(
2400 0 /* top padding */, 0 /* right padding */,
2401 0 /* bottom padding */, 0 /* left padding */,
2402 1 /* kernel height */, 1 /* kernel width */,
2403 1 /* subsampling height */, 1 /* subsampling width */,
2404 1 /* dilation_height */, 1 /* dilation_width */,
2405 1 /* groups */,
2406 160 /* input channels per group */,
2407 960 /* output_channels_per_group */,
2408 160 /* input pixel stride */,
2409 960 /* output pixel stride */,
2410 w236.data(), w237.data(),
2411 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2412 0 /* flags */,
2413 &op106);
2414 if (status != xnn_status_success) {
2415 std::cerr << "failed to create operation #106" << std::endl;
2416 return ExecutionPlan();
2417 }
2418 operators.emplace_back(op106, xnn_delete_operator);
2419
2420 xnn_operator_t op107 = nullptr;
2421 status = xnn_create_hardswish_nc_f16(
2422 960 /* channels */,
2423 960 /* input stride */,
2424 960 /* output stride */,
2425 0 /* flags */,
2426 &op107);
2427 if (status != xnn_status_success) {
2428 std::cerr << "failed to create operation #107" << std::endl;
2429 return ExecutionPlan();
2430 }
2431 operators.emplace_back(op107, xnn_delete_operator);
2432
2433 xnn_operator_t op108 = nullptr;
2434 status = xnn_create_global_average_pooling_nwc_f16(
2435 960 /* channels */, 960 /* input stride */, 960 /* output stride */,
2436 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2437 0 /* flags */,
2438 &op108);
2439 if (status != xnn_status_success) {
2440 std::cerr << "failed to create operation #108" << std::endl;
2441 return ExecutionPlan();
2442 }
2443 operators.emplace_back(op108, xnn_delete_operator);
2444
2445 xnn_operator_t op109 = nullptr;
2446 status = xnn_create_convolution2d_nhwc_f16(
2447 0 /* top padding */, 0 /* right padding */,
2448 0 /* bottom padding */, 0 /* left padding */,
2449 1 /* kernel height */, 1 /* kernel width */,
2450 1 /* subsampling height */, 1 /* subsampling width */,
2451 1 /* dilation_height */, 1 /* dilation_width */,
2452 1 /* groups */,
2453 960 /* input channels per group */,
2454 1280 /* output_channels_per_group */,
2455 960 /* input pixel stride */,
2456 1280 /* output pixel stride */,
2457 w238.data(), w239.data(),
2458 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2459 0 /* flags */,
2460 &op109);
2461 if (status != xnn_status_success) {
2462 std::cerr << "failed to create operation #109" << std::endl;
2463 return ExecutionPlan();
2464 }
2465 operators.emplace_back(op109, xnn_delete_operator);
2466
2467 xnn_operator_t op110 = nullptr;
2468 status = xnn_create_hardswish_nc_f16(
2469 1280 /* channels */,
2470 1280 /* input stride */,
2471 1280 /* output stride */,
2472 0 /* flags */,
2473 &op110);
2474 if (status != xnn_status_success) {
2475 std::cerr << "failed to create operation #110" << std::endl;
2476 return ExecutionPlan();
2477 }
2478 operators.emplace_back(op110, xnn_delete_operator);
2479
2480 xnn_operator_t op111 = nullptr;
2481 status = xnn_create_global_average_pooling_nwc_f16(
2482 1280 /* channels */, 1280 /* input stride */, 1280 /* output stride */,
2483 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
2484 0 /* flags */,
2485 &op111);
2486 if (status != xnn_status_success) {
2487 std::cerr << "failed to create operation #111" << std::endl;
2488 return ExecutionPlan();
2489 }
2490 operators.emplace_back(op111, xnn_delete_operator);
2491
2492 xnn_operator_t op112 = nullptr;
2493 status = xnn_create_convolution2d_nhwc_f16(
2494 0 /* top padding */, 0 /* right padding */,
2495 0 /* bottom padding */, 0 /* left padding */,
2496 1 /* kernel height */, 1 /* kernel width */,
2497 1 /* subsampling height */, 1 /* subsampling width */,
2498 1 /* dilation_height */, 1 /* dilation_width */,
2499 1 /* groups */,
2500 1280 /* input channels per group */,
2501 1001 /* output_channels_per_group */,
2502 1280 /* input pixel stride */,
2503 1001 /* output pixel stride */,
2504 w240.data(), w241.data(),
2505 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
2506 0 /* flags */,
2507 &op112);
2508 if (status != xnn_status_success) {
2509 std::cerr << "failed to create operation #112" << std::endl;
2510 return ExecutionPlan();
2511 }
2512 operators.emplace_back(op112, xnn_delete_operator);
2513
2514
2515
2516 status = xnn_setup_convolution2d_nhwc_f16(
2517 op0,
2518 1 /* batch size */, 224 /* input height */, 224 /* input width */,
2519 v0.data() /* input */, v1.data() /* output */,
2520 threadpool /* threadpool */);
2521 if (status != xnn_status_success) {
2522 std::cerr << "failed to setup operation #0" << std::endl;
2523 return ExecutionPlan();
2524 }
2525
2526 status = xnn_setup_hardswish_nc_f16(
2527 op1,
2528 12544 /* batch size */,
2529 v1.data() /* input */, v2.data() /* output */,
2530 threadpool /* threadpool */);
2531 if (status != xnn_status_success) {
2532 std::cerr << "failed to setup operation #1" << std::endl;
2533 return ExecutionPlan();
2534 }
2535
2536 status = xnn_setup_convolution2d_nhwc_f16(
2537 op2,
2538 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2539 v2.data() /* input */, v3.data() /* output */,
2540 threadpool /* threadpool */);
2541 if (status != xnn_status_success) {
2542 std::cerr << "failed to setup operation #2" << std::endl;
2543 return ExecutionPlan();
2544 }
2545
2546 status = xnn_setup_convolution2d_nhwc_f16(
2547 op3,
2548 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2549 v3.data() /* input */, v4.data() /* output */,
2550 threadpool /* threadpool */);
2551 if (status != xnn_status_success) {
2552 std::cerr << "failed to setup operation #3" << std::endl;
2553 return ExecutionPlan();
2554 }
2555
2556 {
2557 const size_t a_shape[] = { 1, 112, 112, 16 };
2558 const size_t b_shape[] = { 1, 112, 112, 16 };
2559 status = xnn_setup_add_nd_f16(
2560 op4,
2561 4, a_shape, 4, b_shape,
2562 v4.data() /* a */, v2.data() /* b */, v5.data() /* output */,
2563 threadpool /* threadpool */);
2564 }
2565 if (status != xnn_status_success) {
2566 std::cerr << "failed to setup operation #4" << std::endl;
2567 return ExecutionPlan();
2568 }
2569
2570 status = xnn_setup_convolution2d_nhwc_f16(
2571 op5,
2572 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2573 v5.data() /* input */, v6.data() /* output */,
2574 threadpool /* threadpool */);
2575 if (status != xnn_status_success) {
2576 std::cerr << "failed to setup operation #5" << std::endl;
2577 return ExecutionPlan();
2578 }
2579
2580 status = xnn_setup_convolution2d_nhwc_f16(
2581 op6,
2582 1 /* batch size */, 112 /* input height */, 112 /* input width */,
2583 v6.data() /* input */, v7.data() /* output */,
2584 threadpool /* threadpool */);
2585 if (status != xnn_status_success) {
2586 std::cerr << "failed to setup operation #6" << std::endl;
2587 return ExecutionPlan();
2588 }
2589
2590 status = xnn_setup_convolution2d_nhwc_f16(
2591 op7,
2592 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2593 v7.data() /* input */, v8.data() /* output */,
2594 threadpool /* threadpool */);
2595 if (status != xnn_status_success) {
2596 std::cerr << "failed to setup operation #7" << std::endl;
2597 return ExecutionPlan();
2598 }
2599
2600 status = xnn_setup_convolution2d_nhwc_f16(
2601 op8,
2602 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2603 v8.data() /* input */, v9.data() /* output */,
2604 threadpool /* threadpool */);
2605 if (status != xnn_status_success) {
2606 std::cerr << "failed to setup operation #8" << std::endl;
2607 return ExecutionPlan();
2608 }
2609
2610 status = xnn_setup_convolution2d_nhwc_f16(
2611 op9,
2612 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2613 v9.data() /* input */, v10.data() /* output */,
2614 threadpool /* threadpool */);
2615 if (status != xnn_status_success) {
2616 std::cerr << "failed to setup operation #9" << std::endl;
2617 return ExecutionPlan();
2618 }
2619
2620 status = xnn_setup_convolution2d_nhwc_f16(
2621 op10,
2622 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2623 v10.data() /* input */, v11.data() /* output */,
2624 threadpool /* threadpool */);
2625 if (status != xnn_status_success) {
2626 std::cerr << "failed to setup operation #10" << std::endl;
2627 return ExecutionPlan();
2628 }
2629
2630 {
2631 const size_t a_shape[] = { 1, 56, 56, 24 };
2632 const size_t b_shape[] = { 1, 56, 56, 24 };
2633 status = xnn_setup_add_nd_f16(
2634 op11,
2635 4, a_shape, 4, b_shape,
2636 v11.data() /* a */, v8.data() /* b */, v12.data() /* output */,
2637 threadpool /* threadpool */);
2638 }
2639 if (status != xnn_status_success) {
2640 std::cerr << "failed to setup operation #11" << std::endl;
2641 return ExecutionPlan();
2642 }
2643
2644 status = xnn_setup_convolution2d_nhwc_f16(
2645 op12,
2646 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2647 v12.data() /* input */, v13.data() /* output */,
2648 threadpool /* threadpool */);
2649 if (status != xnn_status_success) {
2650 std::cerr << "failed to setup operation #12" << std::endl;
2651 return ExecutionPlan();
2652 }
2653
2654 status = xnn_setup_convolution2d_nhwc_f16(
2655 op13,
2656 1 /* batch size */, 56 /* input height */, 56 /* input width */,
2657 v13.data() /* input */, v14.data() /* output */,
2658 threadpool /* threadpool */);
2659 if (status != xnn_status_success) {
2660 std::cerr << "failed to setup operation #13" << std::endl;
2661 return ExecutionPlan();
2662 }
2663
2664 status = xnn_setup_global_average_pooling_nwc_f16(
2665 op14,
2666 1 /* batch size */, 784 /* width */,
2667 v14.data() /* input */, v15.data() /* output */,
2668 threadpool /* threadpool */);
2669 if (status != xnn_status_success) {
2670 std::cerr << "failed to setup operation #14" << std::endl;
2671 return ExecutionPlan();
2672 }
2673
2674 status = xnn_setup_convolution2d_nhwc_f16(
2675 op15,
2676 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2677 v15.data() /* input */, v16.data() /* output */,
2678 threadpool /* threadpool */);
2679 if (status != xnn_status_success) {
2680 std::cerr << "failed to setup operation #15" << std::endl;
2681 return ExecutionPlan();
2682 }
2683
2684 status = xnn_setup_convolution2d_nhwc_f16(
2685 op16,
2686 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2687 v16.data() /* input */, v17.data() /* output */,
2688 threadpool /* threadpool */);
2689 if (status != xnn_status_success) {
2690 std::cerr << "failed to setup operation #16" << std::endl;
2691 return ExecutionPlan();
2692 }
2693
2694 {
2695 const size_t a_shape[] = { 1, 28, 28, 72 };
2696 const size_t b_shape[] = { 1, 1, 1, 72 };
2697 status = xnn_setup_multiply_nd_f16(
2698 op17,
2699 4, a_shape, 4, b_shape,
2700 v14.data() /* a */, v17.data() /* b */, v18.data() /* output */,
2701 threadpool /* threadpool */);
2702 }
2703 if (status != xnn_status_success) {
2704 std::cerr << "failed to setup operation #17" << std::endl;
2705 return ExecutionPlan();
2706 }
2707
2708 status = xnn_setup_convolution2d_nhwc_f16(
2709 op18,
2710 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2711 v18.data() /* input */, v19.data() /* output */,
2712 threadpool /* threadpool */);
2713 if (status != xnn_status_success) {
2714 std::cerr << "failed to setup operation #18" << std::endl;
2715 return ExecutionPlan();
2716 }
2717
2718 status = xnn_setup_convolution2d_nhwc_f16(
2719 op19,
2720 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2721 v19.data() /* input */, v20.data() /* output */,
2722 threadpool /* threadpool */);
2723 if (status != xnn_status_success) {
2724 std::cerr << "failed to setup operation #19" << std::endl;
2725 return ExecutionPlan();
2726 }
2727
2728 status = xnn_setup_convolution2d_nhwc_f16(
2729 op20,
2730 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2731 v20.data() /* input */, v21.data() /* output */,
2732 threadpool /* threadpool */);
2733 if (status != xnn_status_success) {
2734 std::cerr << "failed to setup operation #20" << std::endl;
2735 return ExecutionPlan();
2736 }
2737
2738 status = xnn_setup_global_average_pooling_nwc_f16(
2739 op21,
2740 1 /* batch size */, 784 /* width */,
2741 v21.data() /* input */, v22.data() /* output */,
2742 threadpool /* threadpool */);
2743 if (status != xnn_status_success) {
2744 std::cerr << "failed to setup operation #21" << std::endl;
2745 return ExecutionPlan();
2746 }
2747
2748 status = xnn_setup_convolution2d_nhwc_f16(
2749 op22,
2750 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2751 v22.data() /* input */, v23.data() /* output */,
2752 threadpool /* threadpool */);
2753 if (status != xnn_status_success) {
2754 std::cerr << "failed to setup operation #22" << std::endl;
2755 return ExecutionPlan();
2756 }
2757
2758 status = xnn_setup_convolution2d_nhwc_f16(
2759 op23,
2760 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2761 v23.data() /* input */, v24.data() /* output */,
2762 threadpool /* threadpool */);
2763 if (status != xnn_status_success) {
2764 std::cerr << "failed to setup operation #23" << std::endl;
2765 return ExecutionPlan();
2766 }
2767
2768 {
2769 const size_t a_shape[] = { 1, 28, 28, 120 };
2770 const size_t b_shape[] = { 1, 1, 1, 120 };
2771 status = xnn_setup_multiply_nd_f16(
2772 op24,
2773 4, a_shape, 4, b_shape,
2774 v21.data() /* a */, v24.data() /* b */, v25.data() /* output */,
2775 threadpool /* threadpool */);
2776 }
2777 if (status != xnn_status_success) {
2778 std::cerr << "failed to setup operation #24" << std::endl;
2779 return ExecutionPlan();
2780 }
2781
2782 status = xnn_setup_convolution2d_nhwc_f16(
2783 op25,
2784 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2785 v25.data() /* input */, v26.data() /* output */,
2786 threadpool /* threadpool */);
2787 if (status != xnn_status_success) {
2788 std::cerr << "failed to setup operation #25" << std::endl;
2789 return ExecutionPlan();
2790 }
2791
2792 {
2793 const size_t a_shape[] = { 1, 28, 28, 40 };
2794 const size_t b_shape[] = { 1, 28, 28, 40 };
2795 status = xnn_setup_add_nd_f16(
2796 op26,
2797 4, a_shape, 4, b_shape,
2798 v26.data() /* a */, v19.data() /* b */, v27.data() /* output */,
2799 threadpool /* threadpool */);
2800 }
2801 if (status != xnn_status_success) {
2802 std::cerr << "failed to setup operation #26" << std::endl;
2803 return ExecutionPlan();
2804 }
2805
2806 status = xnn_setup_convolution2d_nhwc_f16(
2807 op27,
2808 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2809 v27.data() /* input */, v28.data() /* output */,
2810 threadpool /* threadpool */);
2811 if (status != xnn_status_success) {
2812 std::cerr << "failed to setup operation #27" << std::endl;
2813 return ExecutionPlan();
2814 }
2815
2816 status = xnn_setup_convolution2d_nhwc_f16(
2817 op28,
2818 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2819 v28.data() /* input */, v29.data() /* output */,
2820 threadpool /* threadpool */);
2821 if (status != xnn_status_success) {
2822 std::cerr << "failed to setup operation #28" << std::endl;
2823 return ExecutionPlan();
2824 }
2825
2826 status = xnn_setup_global_average_pooling_nwc_f16(
2827 op29,
2828 1 /* batch size */, 784 /* width */,
2829 v29.data() /* input */, v30.data() /* output */,
2830 threadpool /* threadpool */);
2831 if (status != xnn_status_success) {
2832 std::cerr << "failed to setup operation #29" << std::endl;
2833 return ExecutionPlan();
2834 }
2835
2836 status = xnn_setup_convolution2d_nhwc_f16(
2837 op30,
2838 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2839 v30.data() /* input */, v31.data() /* output */,
2840 threadpool /* threadpool */);
2841 if (status != xnn_status_success) {
2842 std::cerr << "failed to setup operation #30" << std::endl;
2843 return ExecutionPlan();
2844 }
2845
2846 status = xnn_setup_convolution2d_nhwc_f16(
2847 op31,
2848 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2849 v31.data() /* input */, v32.data() /* output */,
2850 threadpool /* threadpool */);
2851 if (status != xnn_status_success) {
2852 std::cerr << "failed to setup operation #31" << std::endl;
2853 return ExecutionPlan();
2854 }
2855
2856 {
2857 const size_t a_shape[] = { 1, 28, 28, 120 };
2858 const size_t b_shape[] = { 1, 1, 1, 120 };
2859 status = xnn_setup_multiply_nd_f16(
2860 op32,
2861 4, a_shape, 4, b_shape,
2862 v29.data() /* a */, v32.data() /* b */, v33.data() /* output */,
2863 threadpool /* threadpool */);
2864 }
2865 if (status != xnn_status_success) {
2866 std::cerr << "failed to setup operation #32" << std::endl;
2867 return ExecutionPlan();
2868 }
2869
2870 status = xnn_setup_convolution2d_nhwc_f16(
2871 op33,
2872 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2873 v33.data() /* input */, v34.data() /* output */,
2874 threadpool /* threadpool */);
2875 if (status != xnn_status_success) {
2876 std::cerr << "failed to setup operation #33" << std::endl;
2877 return ExecutionPlan();
2878 }
2879
2880 {
2881 const size_t a_shape[] = { 1, 28, 28, 40 };
2882 const size_t b_shape[] = { 1, 28, 28, 40 };
2883 status = xnn_setup_add_nd_f16(
2884 op34,
2885 4, a_shape, 4, b_shape,
2886 v34.data() /* a */, v27.data() /* b */, v35.data() /* output */,
2887 threadpool /* threadpool */);
2888 }
2889 if (status != xnn_status_success) {
2890 std::cerr << "failed to setup operation #34" << std::endl;
2891 return ExecutionPlan();
2892 }
2893
2894 status = xnn_setup_convolution2d_nhwc_f16(
2895 op35,
2896 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2897 v35.data() /* input */, v36.data() /* output */,
2898 threadpool /* threadpool */);
2899 if (status != xnn_status_success) {
2900 std::cerr << "failed to setup operation #35" << std::endl;
2901 return ExecutionPlan();
2902 }
2903
2904 status = xnn_setup_hardswish_nc_f16(
2905 op36,
2906 784 /* batch size */,
2907 v36.data() /* input */, v37.data() /* output */,
2908 threadpool /* threadpool */);
2909 if (status != xnn_status_success) {
2910 std::cerr << "failed to setup operation #36" << std::endl;
2911 return ExecutionPlan();
2912 }
2913
2914 status = xnn_setup_convolution2d_nhwc_f16(
2915 op37,
2916 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2917 v37.data() /* input */, v38.data() /* output */,
2918 threadpool /* threadpool */);
2919 if (status != xnn_status_success) {
2920 std::cerr << "failed to setup operation #37" << std::endl;
2921 return ExecutionPlan();
2922 }
2923
2924 status = xnn_setup_hardswish_nc_f16(
2925 op38,
2926 196 /* batch size */,
2927 v38.data() /* input */, v39.data() /* output */,
2928 threadpool /* threadpool */);
2929 if (status != xnn_status_success) {
2930 std::cerr << "failed to setup operation #38" << std::endl;
2931 return ExecutionPlan();
2932 }
2933
2934 status = xnn_setup_convolution2d_nhwc_f16(
2935 op39,
2936 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2937 v39.data() /* input */, v40.data() /* output */,
2938 threadpool /* threadpool */);
2939 if (status != xnn_status_success) {
2940 std::cerr << "failed to setup operation #39" << std::endl;
2941 return ExecutionPlan();
2942 }
2943
2944 status = xnn_setup_convolution2d_nhwc_f16(
2945 op40,
2946 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2947 v40.data() /* input */, v41.data() /* output */,
2948 threadpool /* threadpool */);
2949 if (status != xnn_status_success) {
2950 std::cerr << "failed to setup operation #40" << std::endl;
2951 return ExecutionPlan();
2952 }
2953
2954 status = xnn_setup_hardswish_nc_f16(
2955 op41,
2956 196 /* batch size */,
2957 v41.data() /* input */, v42.data() /* output */,
2958 threadpool /* threadpool */);
2959 if (status != xnn_status_success) {
2960 std::cerr << "failed to setup operation #41" << std::endl;
2961 return ExecutionPlan();
2962 }
2963
2964 status = xnn_setup_convolution2d_nhwc_f16(
2965 op42,
2966 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2967 v42.data() /* input */, v43.data() /* output */,
2968 threadpool /* threadpool */);
2969 if (status != xnn_status_success) {
2970 std::cerr << "failed to setup operation #42" << std::endl;
2971 return ExecutionPlan();
2972 }
2973
2974 status = xnn_setup_hardswish_nc_f16(
2975 op43,
2976 196 /* batch size */,
2977 v43.data() /* input */, v44.data() /* output */,
2978 threadpool /* threadpool */);
2979 if (status != xnn_status_success) {
2980 std::cerr << "failed to setup operation #43" << std::endl;
2981 return ExecutionPlan();
2982 }
2983
2984 status = xnn_setup_convolution2d_nhwc_f16(
2985 op44,
2986 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2987 v44.data() /* input */, v45.data() /* output */,
2988 threadpool /* threadpool */);
2989 if (status != xnn_status_success) {
2990 std::cerr << "failed to setup operation #44" << std::endl;
2991 return ExecutionPlan();
2992 }
2993
2994 {
2995 const size_t a_shape[] = { 1, 14, 14, 80 };
2996 const size_t b_shape[] = { 1, 14, 14, 80 };
2997 status = xnn_setup_add_nd_f16(
2998 op45,
2999 4, a_shape, 4, b_shape,
3000 v45.data() /* a */, v40.data() /* b */, v46.data() /* output */,
3001 threadpool /* threadpool */);
3002 }
3003 if (status != xnn_status_success) {
3004 std::cerr << "failed to setup operation #45" << std::endl;
3005 return ExecutionPlan();
3006 }
3007
3008 status = xnn_setup_convolution2d_nhwc_f16(
3009 op46,
3010 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3011 v46.data() /* input */, v47.data() /* output */,
3012 threadpool /* threadpool */);
3013 if (status != xnn_status_success) {
3014 std::cerr << "failed to setup operation #46" << std::endl;
3015 return ExecutionPlan();
3016 }
3017
3018 status = xnn_setup_hardswish_nc_f16(
3019 op47,
3020 196 /* batch size */,
3021 v47.data() /* input */, v48.data() /* output */,
3022 threadpool /* threadpool */);
3023 if (status != xnn_status_success) {
3024 std::cerr << "failed to setup operation #47" << std::endl;
3025 return ExecutionPlan();
3026 }
3027
3028 status = xnn_setup_convolution2d_nhwc_f16(
3029 op48,
3030 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3031 v48.data() /* input */, v49.data() /* output */,
3032 threadpool /* threadpool */);
3033 if (status != xnn_status_success) {
3034 std::cerr << "failed to setup operation #48" << std::endl;
3035 return ExecutionPlan();
3036 }
3037
3038 status = xnn_setup_hardswish_nc_f16(
3039 op49,
3040 196 /* batch size */,
3041 v49.data() /* input */, v50.data() /* output */,
3042 threadpool /* threadpool */);
3043 if (status != xnn_status_success) {
3044 std::cerr << "failed to setup operation #49" << std::endl;
3045 return ExecutionPlan();
3046 }
3047
3048 status = xnn_setup_convolution2d_nhwc_f16(
3049 op50,
3050 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3051 v50.data() /* input */, v51.data() /* output */,
3052 threadpool /* threadpool */);
3053 if (status != xnn_status_success) {
3054 std::cerr << "failed to setup operation #50" << std::endl;
3055 return ExecutionPlan();
3056 }
3057
3058 {
3059 const size_t a_shape[] = { 1, 14, 14, 80 };
3060 const size_t b_shape[] = { 1, 14, 14, 80 };
3061 status = xnn_setup_add_nd_f16(
3062 op51,
3063 4, a_shape, 4, b_shape,
3064 v51.data() /* a */, v46.data() /* b */, v52.data() /* output */,
3065 threadpool /* threadpool */);
3066 }
3067 if (status != xnn_status_success) {
3068 std::cerr << "failed to setup operation #51" << std::endl;
3069 return ExecutionPlan();
3070 }
3071
3072 status = xnn_setup_convolution2d_nhwc_f16(
3073 op52,
3074 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3075 v52.data() /* input */, v53.data() /* output */,
3076 threadpool /* threadpool */);
3077 if (status != xnn_status_success) {
3078 std::cerr << "failed to setup operation #52" << std::endl;
3079 return ExecutionPlan();
3080 }
3081
3082 status = xnn_setup_hardswish_nc_f16(
3083 op53,
3084 196 /* batch size */,
3085 v53.data() /* input */, v54.data() /* output */,
3086 threadpool /* threadpool */);
3087 if (status != xnn_status_success) {
3088 std::cerr << "failed to setup operation #53" << std::endl;
3089 return ExecutionPlan();
3090 }
3091
3092 status = xnn_setup_convolution2d_nhwc_f16(
3093 op54,
3094 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3095 v54.data() /* input */, v55.data() /* output */,
3096 threadpool /* threadpool */);
3097 if (status != xnn_status_success) {
3098 std::cerr << "failed to setup operation #54" << std::endl;
3099 return ExecutionPlan();
3100 }
3101
3102 status = xnn_setup_hardswish_nc_f16(
3103 op55,
3104 196 /* batch size */,
3105 v55.data() /* input */, v56.data() /* output */,
3106 threadpool /* threadpool */);
3107 if (status != xnn_status_success) {
3108 std::cerr << "failed to setup operation #55" << std::endl;
3109 return ExecutionPlan();
3110 }
3111
3112 status = xnn_setup_convolution2d_nhwc_f16(
3113 op56,
3114 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3115 v56.data() /* input */, v57.data() /* output */,
3116 threadpool /* threadpool */);
3117 if (status != xnn_status_success) {
3118 std::cerr << "failed to setup operation #56" << std::endl;
3119 return ExecutionPlan();
3120 }
3121
3122 {
3123 const size_t a_shape[] = { 1, 14, 14, 80 };
3124 const size_t b_shape[] = { 1, 14, 14, 80 };
3125 status = xnn_setup_add_nd_f16(
3126 op57,
3127 4, a_shape, 4, b_shape,
3128 v57.data() /* a */, v52.data() /* b */, v58.data() /* output */,
3129 threadpool /* threadpool */);
3130 }
3131 if (status != xnn_status_success) {
3132 std::cerr << "failed to setup operation #57" << std::endl;
3133 return ExecutionPlan();
3134 }
3135
3136 status = xnn_setup_convolution2d_nhwc_f16(
3137 op58,
3138 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3139 v58.data() /* input */, v59.data() /* output */,
3140 threadpool /* threadpool */);
3141 if (status != xnn_status_success) {
3142 std::cerr << "failed to setup operation #58" << std::endl;
3143 return ExecutionPlan();
3144 }
3145
3146 status = xnn_setup_hardswish_nc_f16(
3147 op59,
3148 196 /* batch size */,
3149 v59.data() /* input */, v60.data() /* output */,
3150 threadpool /* threadpool */);
3151 if (status != xnn_status_success) {
3152 std::cerr << "failed to setup operation #59" << std::endl;
3153 return ExecutionPlan();
3154 }
3155
3156 status = xnn_setup_convolution2d_nhwc_f16(
3157 op60,
3158 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3159 v60.data() /* input */, v61.data() /* output */,
3160 threadpool /* threadpool */);
3161 if (status != xnn_status_success) {
3162 std::cerr << "failed to setup operation #60" << std::endl;
3163 return ExecutionPlan();
3164 }
3165
3166 status = xnn_setup_hardswish_nc_f16(
3167 op61,
3168 196 /* batch size */,
3169 v61.data() /* input */, v62.data() /* output */,
3170 threadpool /* threadpool */);
3171 if (status != xnn_status_success) {
3172 std::cerr << "failed to setup operation #61" << std::endl;
3173 return ExecutionPlan();
3174 }
3175
3176 status = xnn_setup_global_average_pooling_nwc_f16(
3177 op62,
3178 1 /* batch size */, 196 /* width */,
3179 v62.data() /* input */, v63.data() /* output */,
3180 threadpool /* threadpool */);
3181 if (status != xnn_status_success) {
3182 std::cerr << "failed to setup operation #62" << std::endl;
3183 return ExecutionPlan();
3184 }
3185
3186 status = xnn_setup_convolution2d_nhwc_f16(
3187 op63,
3188 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3189 v63.data() /* input */, v64.data() /* output */,
3190 threadpool /* threadpool */);
3191 if (status != xnn_status_success) {
3192 std::cerr << "failed to setup operation #63" << std::endl;
3193 return ExecutionPlan();
3194 }
3195
3196 status = xnn_setup_convolution2d_nhwc_f16(
3197 op64,
3198 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3199 v64.data() /* input */, v65.data() /* output */,
3200 threadpool /* threadpool */);
3201 if (status != xnn_status_success) {
3202 std::cerr << "failed to setup operation #64" << std::endl;
3203 return ExecutionPlan();
3204 }
3205
3206 {
3207 const size_t a_shape[] = { 1, 14, 14, 480 };
3208 const size_t b_shape[] = { 1, 1, 1, 480 };
3209 status = xnn_setup_multiply_nd_f16(
3210 op65,
3211 4, a_shape, 4, b_shape,
3212 v62.data() /* a */, v65.data() /* b */, v66.data() /* output */,
3213 threadpool /* threadpool */);
3214 }
3215 if (status != xnn_status_success) {
3216 std::cerr << "failed to setup operation #65" << std::endl;
3217 return ExecutionPlan();
3218 }
3219
3220 status = xnn_setup_convolution2d_nhwc_f16(
3221 op66,
3222 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3223 v66.data() /* input */, v67.data() /* output */,
3224 threadpool /* threadpool */);
3225 if (status != xnn_status_success) {
3226 std::cerr << "failed to setup operation #66" << std::endl;
3227 return ExecutionPlan();
3228 }
3229
3230 status = xnn_setup_convolution2d_nhwc_f16(
3231 op67,
3232 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3233 v67.data() /* input */, v68.data() /* output */,
3234 threadpool /* threadpool */);
3235 if (status != xnn_status_success) {
3236 std::cerr << "failed to setup operation #67" << std::endl;
3237 return ExecutionPlan();
3238 }
3239
3240 status = xnn_setup_hardswish_nc_f16(
3241 op68,
3242 196 /* batch size */,
3243 v68.data() /* input */, v69.data() /* output */,
3244 threadpool /* threadpool */);
3245 if (status != xnn_status_success) {
3246 std::cerr << "failed to setup operation #68" << std::endl;
3247 return ExecutionPlan();
3248 }
3249
3250 status = xnn_setup_convolution2d_nhwc_f16(
3251 op69,
3252 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3253 v69.data() /* input */, v70.data() /* output */,
3254 threadpool /* threadpool */);
3255 if (status != xnn_status_success) {
3256 std::cerr << "failed to setup operation #69" << std::endl;
3257 return ExecutionPlan();
3258 }
3259
3260 status = xnn_setup_hardswish_nc_f16(
3261 op70,
3262 196 /* batch size */,
3263 v70.data() /* input */, v71.data() /* output */,
3264 threadpool /* threadpool */);
3265 if (status != xnn_status_success) {
3266 std::cerr << "failed to setup operation #70" << std::endl;
3267 return ExecutionPlan();
3268 }
3269
3270 status = xnn_setup_global_average_pooling_nwc_f16(
3271 op71,
3272 1 /* batch size */, 196 /* width */,
3273 v71.data() /* input */, v72.data() /* output */,
3274 threadpool /* threadpool */);
3275 if (status != xnn_status_success) {
3276 std::cerr << "failed to setup operation #71" << std::endl;
3277 return ExecutionPlan();
3278 }
3279
3280 status = xnn_setup_convolution2d_nhwc_f16(
3281 op72,
3282 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3283 v72.data() /* input */, v73.data() /* output */,
3284 threadpool /* threadpool */);
3285 if (status != xnn_status_success) {
3286 std::cerr << "failed to setup operation #72" << std::endl;
3287 return ExecutionPlan();
3288 }
3289
3290 status = xnn_setup_convolution2d_nhwc_f16(
3291 op73,
3292 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3293 v73.data() /* input */, v74.data() /* output */,
3294 threadpool /* threadpool */);
3295 if (status != xnn_status_success) {
3296 std::cerr << "failed to setup operation #73" << std::endl;
3297 return ExecutionPlan();
3298 }
3299
3300 {
3301 const size_t a_shape[] = { 1, 14, 14, 672 };
3302 const size_t b_shape[] = { 1, 1, 1, 672 };
3303 status = xnn_setup_multiply_nd_f16(
3304 op74,
3305 4, a_shape, 4, b_shape,
3306 v71.data() /* a */, v74.data() /* b */, v75.data() /* output */,
3307 threadpool /* threadpool */);
3308 }
3309 if (status != xnn_status_success) {
3310 std::cerr << "failed to setup operation #74" << std::endl;
3311 return ExecutionPlan();
3312 }
3313
3314 status = xnn_setup_convolution2d_nhwc_f16(
3315 op75,
3316 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3317 v75.data() /* input */, v76.data() /* output */,
3318 threadpool /* threadpool */);
3319 if (status != xnn_status_success) {
3320 std::cerr << "failed to setup operation #75" << std::endl;
3321 return ExecutionPlan();
3322 }
3323
3324 {
3325 const size_t a_shape[] = { 1, 14, 14, 112 };
3326 const size_t b_shape[] = { 1, 14, 14, 112 };
3327 status = xnn_setup_add_nd_f16(
3328 op76,
3329 4, a_shape, 4, b_shape,
3330 v76.data() /* a */, v67.data() /* b */, v77.data() /* output */,
3331 threadpool /* threadpool */);
3332 }
3333 if (status != xnn_status_success) {
3334 std::cerr << "failed to setup operation #76" << std::endl;
3335 return ExecutionPlan();
3336 }
3337
3338 status = xnn_setup_convolution2d_nhwc_f16(
3339 op77,
3340 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3341 v77.data() /* input */, v78.data() /* output */,
3342 threadpool /* threadpool */);
3343 if (status != xnn_status_success) {
3344 std::cerr << "failed to setup operation #77" << std::endl;
3345 return ExecutionPlan();
3346 }
3347
3348 status = xnn_setup_hardswish_nc_f16(
3349 op78,
3350 196 /* batch size */,
3351 v78.data() /* input */, v79.data() /* output */,
3352 threadpool /* threadpool */);
3353 if (status != xnn_status_success) {
3354 std::cerr << "failed to setup operation #78" << std::endl;
3355 return ExecutionPlan();
3356 }
3357
3358 status = xnn_setup_convolution2d_nhwc_f16(
3359 op79,
3360 1 /* batch size */, 14 /* input height */, 14 /* input width */,
3361 v79.data() /* input */, v80.data() /* output */,
3362 threadpool /* threadpool */);
3363 if (status != xnn_status_success) {
3364 std::cerr << "failed to setup operation #79" << std::endl;
3365 return ExecutionPlan();
3366 }
3367
3368 status = xnn_setup_hardswish_nc_f16(
3369 op80,
3370 49 /* batch size */,
3371 v80.data() /* input */, v81.data() /* output */,
3372 threadpool /* threadpool */);
3373 if (status != xnn_status_success) {
3374 std::cerr << "failed to setup operation #80" << std::endl;
3375 return ExecutionPlan();
3376 }
3377
3378 status = xnn_setup_global_average_pooling_nwc_f16(
3379 op81,
3380 1 /* batch size */, 49 /* width */,
3381 v81.data() /* input */, v82.data() /* output */,
3382 threadpool /* threadpool */);
3383 if (status != xnn_status_success) {
3384 std::cerr << "failed to setup operation #81" << std::endl;
3385 return ExecutionPlan();
3386 }
3387
3388 status = xnn_setup_convolution2d_nhwc_f16(
3389 op82,
3390 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3391 v82.data() /* input */, v83.data() /* output */,
3392 threadpool /* threadpool */);
3393 if (status != xnn_status_success) {
3394 std::cerr << "failed to setup operation #82" << std::endl;
3395 return ExecutionPlan();
3396 }
3397
3398 status = xnn_setup_convolution2d_nhwc_f16(
3399 op83,
3400 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3401 v83.data() /* input */, v84.data() /* output */,
3402 threadpool /* threadpool */);
3403 if (status != xnn_status_success) {
3404 std::cerr << "failed to setup operation #83" << std::endl;
3405 return ExecutionPlan();
3406 }
3407
3408 {
3409 const size_t a_shape[] = { 1, 7, 7, 672 };
3410 const size_t b_shape[] = { 1, 1, 1, 672 };
3411 status = xnn_setup_multiply_nd_f16(
3412 op84,
3413 4, a_shape, 4, b_shape,
3414 v81.data() /* a */, v84.data() /* b */, v85.data() /* output */,
3415 threadpool /* threadpool */);
3416 }
3417 if (status != xnn_status_success) {
3418 std::cerr << "failed to setup operation #84" << std::endl;
3419 return ExecutionPlan();
3420 }
3421
3422 status = xnn_setup_convolution2d_nhwc_f16(
3423 op85,
3424 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3425 v85.data() /* input */, v86.data() /* output */,
3426 threadpool /* threadpool */);
3427 if (status != xnn_status_success) {
3428 std::cerr << "failed to setup operation #85" << std::endl;
3429 return ExecutionPlan();
3430 }
3431
3432 status = xnn_setup_convolution2d_nhwc_f16(
3433 op86,
3434 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3435 v86.data() /* input */, v87.data() /* output */,
3436 threadpool /* threadpool */);
3437 if (status != xnn_status_success) {
3438 std::cerr << "failed to setup operation #86" << std::endl;
3439 return ExecutionPlan();
3440 }
3441
3442 status = xnn_setup_hardswish_nc_f16(
3443 op87,
3444 49 /* batch size */,
3445 v87.data() /* input */, v88.data() /* output */,
3446 threadpool /* threadpool */);
3447 if (status != xnn_status_success) {
3448 std::cerr << "failed to setup operation #87" << std::endl;
3449 return ExecutionPlan();
3450 }
3451
3452 status = xnn_setup_convolution2d_nhwc_f16(
3453 op88,
3454 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3455 v88.data() /* input */, v89.data() /* output */,
3456 threadpool /* threadpool */);
3457 if (status != xnn_status_success) {
3458 std::cerr << "failed to setup operation #88" << std::endl;
3459 return ExecutionPlan();
3460 }
3461
3462 status = xnn_setup_hardswish_nc_f16(
3463 op89,
3464 49 /* batch size */,
3465 v89.data() /* input */, v90.data() /* output */,
3466 threadpool /* threadpool */);
3467 if (status != xnn_status_success) {
3468 std::cerr << "failed to setup operation #89" << std::endl;
3469 return ExecutionPlan();
3470 }
3471
3472 status = xnn_setup_global_average_pooling_nwc_f16(
3473 op90,
3474 1 /* batch size */, 49 /* width */,
3475 v90.data() /* input */, v91.data() /* output */,
3476 threadpool /* threadpool */);
3477 if (status != xnn_status_success) {
3478 std::cerr << "failed to setup operation #90" << std::endl;
3479 return ExecutionPlan();
3480 }
3481
3482 status = xnn_setup_convolution2d_nhwc_f16(
3483 op91,
3484 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3485 v91.data() /* input */, v92.data() /* output */,
3486 threadpool /* threadpool */);
3487 if (status != xnn_status_success) {
3488 std::cerr << "failed to setup operation #91" << std::endl;
3489 return ExecutionPlan();
3490 }
3491
3492 status = xnn_setup_convolution2d_nhwc_f16(
3493 op92,
3494 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3495 v92.data() /* input */, v93.data() /* output */,
3496 threadpool /* threadpool */);
3497 if (status != xnn_status_success) {
3498 std::cerr << "failed to setup operation #92" << std::endl;
3499 return ExecutionPlan();
3500 }
3501
3502 {
3503 const size_t a_shape[] = { 1, 7, 7, 960 };
3504 const size_t b_shape[] = { 1, 1, 1, 960 };
3505 status = xnn_setup_multiply_nd_f16(
3506 op93,
3507 4, a_shape, 4, b_shape,
3508 v90.data() /* a */, v93.data() /* b */, v94.data() /* output */,
3509 threadpool /* threadpool */);
3510 }
3511 if (status != xnn_status_success) {
3512 std::cerr << "failed to setup operation #93" << std::endl;
3513 return ExecutionPlan();
3514 }
3515
3516 status = xnn_setup_convolution2d_nhwc_f16(
3517 op94,
3518 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3519 v94.data() /* input */, v95.data() /* output */,
3520 threadpool /* threadpool */);
3521 if (status != xnn_status_success) {
3522 std::cerr << "failed to setup operation #94" << std::endl;
3523 return ExecutionPlan();
3524 }
3525
3526 {
3527 const size_t a_shape[] = { 1, 7, 7, 160 };
3528 const size_t b_shape[] = { 1, 7, 7, 160 };
3529 status = xnn_setup_add_nd_f16(
3530 op95,
3531 4, a_shape, 4, b_shape,
3532 v95.data() /* a */, v86.data() /* b */, v96.data() /* output */,
3533 threadpool /* threadpool */);
3534 }
3535 if (status != xnn_status_success) {
3536 std::cerr << "failed to setup operation #95" << std::endl;
3537 return ExecutionPlan();
3538 }
3539
3540 status = xnn_setup_convolution2d_nhwc_f16(
3541 op96,
3542 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3543 v96.data() /* input */, v97.data() /* output */,
3544 threadpool /* threadpool */);
3545 if (status != xnn_status_success) {
3546 std::cerr << "failed to setup operation #96" << std::endl;
3547 return ExecutionPlan();
3548 }
3549
3550 status = xnn_setup_hardswish_nc_f16(
3551 op97,
3552 49 /* batch size */,
3553 v97.data() /* input */, v98.data() /* output */,
3554 threadpool /* threadpool */);
3555 if (status != xnn_status_success) {
3556 std::cerr << "failed to setup operation #97" << std::endl;
3557 return ExecutionPlan();
3558 }
3559
3560 status = xnn_setup_convolution2d_nhwc_f16(
3561 op98,
3562 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3563 v98.data() /* input */, v99.data() /* output */,
3564 threadpool /* threadpool */);
3565 if (status != xnn_status_success) {
3566 std::cerr << "failed to setup operation #98" << std::endl;
3567 return ExecutionPlan();
3568 }
3569
3570 status = xnn_setup_hardswish_nc_f16(
3571 op99,
3572 49 /* batch size */,
3573 v99.data() /* input */, v100.data() /* output */,
3574 threadpool /* threadpool */);
3575 if (status != xnn_status_success) {
3576 std::cerr << "failed to setup operation #99" << std::endl;
3577 return ExecutionPlan();
3578 }
3579
3580 status = xnn_setup_global_average_pooling_nwc_f16(
3581 op100,
3582 1 /* batch size */, 49 /* width */,
3583 v100.data() /* input */, v101.data() /* output */,
3584 threadpool /* threadpool */);
3585 if (status != xnn_status_success) {
3586 std::cerr << "failed to setup operation #100" << std::endl;
3587 return ExecutionPlan();
3588 }
3589
3590 status = xnn_setup_convolution2d_nhwc_f16(
3591 op101,
3592 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3593 v101.data() /* input */, v102.data() /* output */,
3594 threadpool /* threadpool */);
3595 if (status != xnn_status_success) {
3596 std::cerr << "failed to setup operation #101" << std::endl;
3597 return ExecutionPlan();
3598 }
3599
3600 status = xnn_setup_convolution2d_nhwc_f16(
3601 op102,
3602 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3603 v102.data() /* input */, v103.data() /* output */,
3604 threadpool /* threadpool */);
3605 if (status != xnn_status_success) {
3606 std::cerr << "failed to setup operation #102" << std::endl;
3607 return ExecutionPlan();
3608 }
3609
3610 {
3611 const size_t a_shape[] = { 1, 7, 7, 960 };
3612 const size_t b_shape[] = { 1, 1, 1, 960 };
3613 status = xnn_setup_multiply_nd_f16(
3614 op103,
3615 4, a_shape, 4, b_shape,
3616 v100.data() /* a */, v103.data() /* b */, v104.data() /* output */,
3617 threadpool /* threadpool */);
3618 }
3619 if (status != xnn_status_success) {
3620 std::cerr << "failed to setup operation #103" << std::endl;
3621 return ExecutionPlan();
3622 }
3623
3624 status = xnn_setup_convolution2d_nhwc_f16(
3625 op104,
3626 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3627 v104.data() /* input */, v105.data() /* output */,
3628 threadpool /* threadpool */);
3629 if (status != xnn_status_success) {
3630 std::cerr << "failed to setup operation #104" << std::endl;
3631 return ExecutionPlan();
3632 }
3633
3634 {
3635 const size_t a_shape[] = { 1, 7, 7, 160 };
3636 const size_t b_shape[] = { 1, 7, 7, 160 };
3637 status = xnn_setup_add_nd_f16(
3638 op105,
3639 4, a_shape, 4, b_shape,
3640 v105.data() /* a */, v96.data() /* b */, v106.data() /* output */,
3641 threadpool /* threadpool */);
3642 }
3643 if (status != xnn_status_success) {
3644 std::cerr << "failed to setup operation #105" << std::endl;
3645 return ExecutionPlan();
3646 }
3647
3648 status = xnn_setup_convolution2d_nhwc_f16(
3649 op106,
3650 1 /* batch size */, 7 /* input height */, 7 /* input width */,
3651 v106.data() /* input */, v107.data() /* output */,
3652 threadpool /* threadpool */);
3653 if (status != xnn_status_success) {
3654 std::cerr << "failed to setup operation #106" << std::endl;
3655 return ExecutionPlan();
3656 }
3657
3658 status = xnn_setup_hardswish_nc_f16(
3659 op107,
3660 49 /* batch size */,
3661 v107.data() /* input */, v108.data() /* output */,
3662 threadpool /* threadpool */);
3663 if (status != xnn_status_success) {
3664 std::cerr << "failed to setup operation #107" << std::endl;
3665 return ExecutionPlan();
3666 }
3667
3668 status = xnn_setup_global_average_pooling_nwc_f16(
3669 op108,
3670 1 /* batch size */, 49 /* width */,
3671 v108.data() /* input */, v109.data() /* output */,
3672 threadpool /* threadpool */);
3673 if (status != xnn_status_success) {
3674 std::cerr << "failed to setup operation #108" << std::endl;
3675 return ExecutionPlan();
3676 }
3677
3678 status = xnn_setup_convolution2d_nhwc_f16(
3679 op109,
3680 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3681 v109.data() /* input */, v110.data() /* output */,
3682 threadpool /* threadpool */);
3683 if (status != xnn_status_success) {
3684 std::cerr << "failed to setup operation #109" << std::endl;
3685 return ExecutionPlan();
3686 }
3687
3688 status = xnn_setup_hardswish_nc_f16(
3689 op110,
3690 1 /* batch size */,
3691 v110.data() /* input */, v111.data() /* output */,
3692 threadpool /* threadpool */);
3693 if (status != xnn_status_success) {
3694 std::cerr << "failed to setup operation #110" << std::endl;
3695 return ExecutionPlan();
3696 }
3697
3698 status = xnn_setup_global_average_pooling_nwc_f16(
3699 op111,
3700 1 /* batch size */, 1 /* width */,
3701 v111.data() /* input */, v112.data() /* output */,
3702 threadpool /* threadpool */);
3703 if (status != xnn_status_success) {
3704 std::cerr << "failed to setup operation #111" << std::endl;
3705 return ExecutionPlan();
3706 }
3707
3708 status = xnn_setup_convolution2d_nhwc_f16(
3709 op112,
3710 1 /* batch size */, 1 /* input height */, 1 /* input width */,
3711 v112.data() /* input */, v113.data() /* output */,
3712 threadpool /* threadpool */);
3713 if (status != xnn_status_success) {
3714 std::cerr << "failed to setup operation #112" << std::endl;
3715 return ExecutionPlan();
3716 }
3717
3718 #pragma clang diagnostic push
3719 #pragma clang diagnostic ignored "-Wpessimizing-move"
3720 return operators;
3721 #pragma clang diagnostic pop
3722 }
3723
3724 } // namespace models
3725