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