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 <xnnpack/cache.h>
16
17 #include "models/models.h"
18
19 namespace models {
20
FP32SparseMobileNetV2(float sparsity,pthreadpool_t threadpool)21 ExecutionPlan FP32SparseMobileNetV2(float sparsity, pthreadpool_t threadpool) {
22 alignas(16) static std::array<float, 150528> v0;
23 alignas(16) static std::array<float, 401408> v1;
24 alignas(16) static std::array<float, 401408> v2;
25 alignas(16) static std::array<float, 200704> v3;
26 alignas(16) static std::array<float, 1204224> v4;
27 alignas(16) static std::array<float, 301056> v5;
28 alignas(16) static std::array<float, 75264> v6;
29 alignas(16) static std::array<float, 451584> v7;
30 alignas(16) static std::array<float, 451584> v8;
31 alignas(16) static std::array<float, 75264> v9;
32 alignas(16) static std::array<float, 75264> v10;
33 alignas(16) static std::array<float, 451584> v11;
34 alignas(16) static std::array<float, 112896> v12;
35 alignas(16) static std::array<float, 25088> v13;
36 alignas(16) static std::array<float, 150528> v14;
37 alignas(16) static std::array<float, 150528> v15;
38 alignas(16) static std::array<float, 25088> v16;
39 alignas(16) static std::array<float, 25088> v17;
40 alignas(16) static std::array<float, 150528> v18;
41 alignas(16) static std::array<float, 150528> v19;
42 alignas(16) static std::array<float, 25088> v20;
43 alignas(16) static std::array<float, 25088> v21;
44 alignas(16) static std::array<float, 150528> v22;
45 alignas(16) static std::array<float, 37632> v23;
46 alignas(16) static std::array<float, 12544> v24;
47 alignas(16) static std::array<float, 75264> v25;
48 alignas(16) static std::array<float, 75264> v26;
49 alignas(16) static std::array<float, 12544> v27;
50 alignas(16) static std::array<float, 12544> v28;
51 alignas(16) static std::array<float, 75264> v29;
52 alignas(16) static std::array<float, 75264> v30;
53 alignas(16) static std::array<float, 12544> v31;
54 alignas(16) static std::array<float, 12544> v32;
55 alignas(16) static std::array<float, 75264> v33;
56 alignas(16) static std::array<float, 75264> v34;
57 alignas(16) static std::array<float, 12544> v35;
58 alignas(16) static std::array<float, 12544> v36;
59 alignas(16) static std::array<float, 75264> v37;
60 alignas(16) static std::array<float, 75264> v38;
61 alignas(16) static std::array<float, 18816> v39;
62 alignas(16) static std::array<float, 112896> v40;
63 alignas(16) static std::array<float, 112896> v41;
64 alignas(16) static std::array<float, 18816> v42;
65 alignas(16) static std::array<float, 18816> v43;
66 alignas(16) static std::array<float, 112896> v44;
67 alignas(16) static std::array<float, 112896> v45;
68 alignas(16) static std::array<float, 18816> v46;
69 alignas(16) static std::array<float, 18816> v47;
70 alignas(16) static std::array<float, 112896> v48;
71 alignas(16) static std::array<float, 28224> v49;
72 alignas(16) static std::array<float, 7840> v50;
73 alignas(16) static std::array<float, 47040> v51;
74 alignas(16) static std::array<float, 47040> v52;
75 alignas(16) static std::array<float, 7840> v53;
76 alignas(16) static std::array<float, 7840> v54;
77 alignas(16) static std::array<float, 47040> v55;
78 alignas(16) static std::array<float, 47040> v56;
79 alignas(16) static std::array<float, 7840> v57;
80 alignas(16) static std::array<float, 7840> v58;
81 alignas(16) static std::array<float, 47040> v59;
82 alignas(16) static std::array<float, 47040> v60;
83 alignas(16) static std::array<float, 15680> v61;
84 alignas(16) static std::array<float, 62720> v62;
85 alignas(16) static std::array<float, 1280> v63;
86 alignas(16) static std::array<float, 1001> v64;
87 alignas(16) static std::array<float, 864> w65;
88 alignas(16) static std::array<float, 32> w66;
89 alignas(16) static std::array<float, 288> w67;
90 alignas(16) static std::array<float, 32> w68;
91 alignas(16) static std::array<float, 512> w69;
92 alignas(16) static std::array<float, 16> w70;
93 alignas(16) static std::array<float, 1536> w71;
94 alignas(16) static std::array<float, 96> w72;
95 alignas(16) static std::array<float, 864> w73;
96 alignas(16) static std::array<float, 96> w74;
97 alignas(16) static std::array<float, 2304> w75;
98 alignas(16) static std::array<float, 24> w76;
99 alignas(16) static std::array<float, 3456> w77;
100 alignas(16) static std::array<float, 144> w78;
101 alignas(16) static std::array<float, 1296> w79;
102 alignas(16) static std::array<float, 144> w80;
103 alignas(16) static std::array<float, 3456> w81;
104 alignas(16) static std::array<float, 24> w82;
105 alignas(16) static std::array<float, 3456> w83;
106 alignas(16) static std::array<float, 144> w84;
107 alignas(16) static std::array<float, 1296> w85;
108 alignas(16) static std::array<float, 144> w86;
109 alignas(16) static std::array<float, 4608> w87;
110 alignas(16) static std::array<float, 32> w88;
111 alignas(16) static std::array<float, 6144> w89;
112 alignas(16) static std::array<float, 192> w90;
113 alignas(16) static std::array<float, 1728> w91;
114 alignas(16) static std::array<float, 192> w92;
115 alignas(16) static std::array<float, 6144> w93;
116 alignas(16) static std::array<float, 32> w94;
117 alignas(16) static std::array<float, 6144> w95;
118 alignas(16) static std::array<float, 192> w96;
119 alignas(16) static std::array<float, 1728> w97;
120 alignas(16) static std::array<float, 192> w98;
121 alignas(16) static std::array<float, 6144> w99;
122 alignas(16) static std::array<float, 32> w100;
123 alignas(16) static std::array<float, 6144> w101;
124 alignas(16) static std::array<float, 192> w102;
125 alignas(16) static std::array<float, 1728> w103;
126 alignas(16) static std::array<float, 192> w104;
127 alignas(16) static std::array<float, 12288> w105;
128 alignas(16) static std::array<float, 64> w106;
129 alignas(16) static std::array<float, 24576> w107;
130 alignas(16) static std::array<float, 384> w108;
131 alignas(16) static std::array<float, 3456> w109;
132 alignas(16) static std::array<float, 384> w110;
133 alignas(16) static std::array<float, 24576> w111;
134 alignas(16) static std::array<float, 64> w112;
135 alignas(16) static std::array<float, 24576> w113;
136 alignas(16) static std::array<float, 384> w114;
137 alignas(16) static std::array<float, 3456> w115;
138 alignas(16) static std::array<float, 384> w116;
139 alignas(16) static std::array<float, 24576> w117;
140 alignas(16) static std::array<float, 64> w118;
141 alignas(16) static std::array<float, 24576> w119;
142 alignas(16) static std::array<float, 384> w120;
143 alignas(16) static std::array<float, 3456> w121;
144 alignas(16) static std::array<float, 384> w122;
145 alignas(16) static std::array<float, 24576> w123;
146 alignas(16) static std::array<float, 64> w124;
147 alignas(16) static std::array<float, 24576> w125;
148 alignas(16) static std::array<float, 384> w126;
149 alignas(16) static std::array<float, 3456> w127;
150 alignas(16) static std::array<float, 384> w128;
151 alignas(16) static std::array<float, 36864> w129;
152 alignas(16) static std::array<float, 96> w130;
153 alignas(16) static std::array<float, 55296> w131;
154 alignas(16) static std::array<float, 576> w132;
155 alignas(16) static std::array<float, 5184> w133;
156 alignas(16) static std::array<float, 576> w134;
157 alignas(16) static std::array<float, 55296> w135;
158 alignas(16) static std::array<float, 96> w136;
159 alignas(16) static std::array<float, 55296> w137;
160 alignas(16) static std::array<float, 576> w138;
161 alignas(16) static std::array<float, 5184> w139;
162 alignas(16) static std::array<float, 576> w140;
163 alignas(16) static std::array<float, 55296> w141;
164 alignas(16) static std::array<float, 96> w142;
165 alignas(16) static std::array<float, 55296> w143;
166 alignas(16) static std::array<float, 576> w144;
167 alignas(16) static std::array<float, 5184> w145;
168 alignas(16) static std::array<float, 576> w146;
169 alignas(16) static std::array<float, 92160> w147;
170 alignas(16) static std::array<float, 160> w148;
171 alignas(16) static std::array<float, 153600> w149;
172 alignas(16) static std::array<float, 960> w150;
173 alignas(16) static std::array<float, 8640> w151;
174 alignas(16) static std::array<float, 960> w152;
175 alignas(16) static std::array<float, 153600> w153;
176 alignas(16) static std::array<float, 160> w154;
177 alignas(16) static std::array<float, 153600> w155;
178 alignas(16) static std::array<float, 960> w156;
179 alignas(16) static std::array<float, 8640> w157;
180 alignas(16) static std::array<float, 960> w158;
181 alignas(16) static std::array<float, 153600> w159;
182 alignas(16) static std::array<float, 160> w160;
183 alignas(16) static std::array<float, 153600> w161;
184 alignas(16) static std::array<float, 960> w162;
185 alignas(16) static std::array<float, 8640> w163;
186 alignas(16) static std::array<float, 960> w164;
187 alignas(16) static std::array<float, 307200> w165;
188 alignas(16) static std::array<float, 320> w166;
189 alignas(16) static std::array<float, 409600> w167;
190 alignas(16) static std::array<float, 1280> w168;
191 alignas(16) static std::array<float, 1281280> w169;
192 alignas(16) static std::array<float, 1001> w170;
193
194 std::random_device random_device;
195 auto rng = std::mt19937(random_device());
196 auto f32rng = std::bind(std::uniform_real_distribution<float>(-1.0f, +1.0f), std::ref(rng));
197 std::generate(v0.begin(), v0.end(), std::ref(f32rng));
198 std::generate(v1.begin(), v1.end(), std::ref(f32rng));
199 std::generate(v2.begin(), v2.end(), std::ref(f32rng));
200 std::generate(v3.begin(), v3.end(), std::ref(f32rng));
201 std::generate(v4.begin(), v4.end(), std::ref(f32rng));
202 std::generate(v5.begin(), v5.end(), std::ref(f32rng));
203 std::generate(v6.begin(), v6.end(), std::ref(f32rng));
204 std::generate(v7.begin(), v7.end(), std::ref(f32rng));
205 std::generate(v8.begin(), v8.end(), std::ref(f32rng));
206 std::generate(v9.begin(), v9.end(), std::ref(f32rng));
207 std::generate(v10.begin(), v10.end(), std::ref(f32rng));
208 std::generate(v11.begin(), v11.end(), std::ref(f32rng));
209 std::generate(v12.begin(), v12.end(), std::ref(f32rng));
210 std::generate(v13.begin(), v13.end(), std::ref(f32rng));
211 std::generate(v14.begin(), v14.end(), std::ref(f32rng));
212 std::generate(v15.begin(), v15.end(), std::ref(f32rng));
213 std::generate(v16.begin(), v16.end(), std::ref(f32rng));
214 std::generate(v17.begin(), v17.end(), std::ref(f32rng));
215 std::generate(v18.begin(), v18.end(), std::ref(f32rng));
216 std::generate(v19.begin(), v19.end(), std::ref(f32rng));
217 std::generate(v20.begin(), v20.end(), std::ref(f32rng));
218 std::generate(v21.begin(), v21.end(), std::ref(f32rng));
219 std::generate(v22.begin(), v22.end(), std::ref(f32rng));
220 std::generate(v23.begin(), v23.end(), std::ref(f32rng));
221 std::generate(v24.begin(), v24.end(), std::ref(f32rng));
222 std::generate(v25.begin(), v25.end(), std::ref(f32rng));
223 std::generate(v26.begin(), v26.end(), std::ref(f32rng));
224 std::generate(v27.begin(), v27.end(), std::ref(f32rng));
225 std::generate(v28.begin(), v28.end(), std::ref(f32rng));
226 std::generate(v29.begin(), v29.end(), std::ref(f32rng));
227 std::generate(v30.begin(), v30.end(), std::ref(f32rng));
228 std::generate(v31.begin(), v31.end(), std::ref(f32rng));
229 std::generate(v32.begin(), v32.end(), std::ref(f32rng));
230 std::generate(v33.begin(), v33.end(), std::ref(f32rng));
231 std::generate(v34.begin(), v34.end(), std::ref(f32rng));
232 std::generate(v35.begin(), v35.end(), std::ref(f32rng));
233 std::generate(v36.begin(), v36.end(), std::ref(f32rng));
234 std::generate(v37.begin(), v37.end(), std::ref(f32rng));
235 std::generate(v38.begin(), v38.end(), std::ref(f32rng));
236 std::generate(v39.begin(), v39.end(), std::ref(f32rng));
237 std::generate(v40.begin(), v40.end(), std::ref(f32rng));
238 std::generate(v41.begin(), v41.end(), std::ref(f32rng));
239 std::generate(v42.begin(), v42.end(), std::ref(f32rng));
240 std::generate(v43.begin(), v43.end(), std::ref(f32rng));
241 std::generate(v44.begin(), v44.end(), std::ref(f32rng));
242 std::generate(v45.begin(), v45.end(), std::ref(f32rng));
243 std::generate(v46.begin(), v46.end(), std::ref(f32rng));
244 std::generate(v47.begin(), v47.end(), std::ref(f32rng));
245 std::generate(v48.begin(), v48.end(), std::ref(f32rng));
246 std::generate(v49.begin(), v49.end(), std::ref(f32rng));
247 std::generate(v50.begin(), v50.end(), std::ref(f32rng));
248 std::generate(v51.begin(), v51.end(), std::ref(f32rng));
249 std::generate(v52.begin(), v52.end(), std::ref(f32rng));
250 std::generate(v53.begin(), v53.end(), std::ref(f32rng));
251 std::generate(v54.begin(), v54.end(), std::ref(f32rng));
252 std::generate(v55.begin(), v55.end(), std::ref(f32rng));
253 std::generate(v56.begin(), v56.end(), std::ref(f32rng));
254 std::generate(v57.begin(), v57.end(), std::ref(f32rng));
255 std::generate(v58.begin(), v58.end(), std::ref(f32rng));
256 std::generate(v59.begin(), v59.end(), std::ref(f32rng));
257 std::generate(v60.begin(), v60.end(), std::ref(f32rng));
258 std::generate(v61.begin(), v61.end(), std::ref(f32rng));
259 std::generate(v62.begin(), v62.end(), std::ref(f32rng));
260 std::generate(v63.begin(), v63.end(), std::ref(f32rng));
261 std::generate(v64.begin(), v64.end(), std::ref(f32rng));
262 std::generate(w65.begin(), w65.end(), std::ref(f32rng));
263 std::generate(w66.begin(), w66.end(), std::ref(f32rng));
264 std::generate(w67.begin(), w67.end(), std::ref(f32rng));
265 std::generate(w68.begin(), w68.end(), std::ref(f32rng));
266 std::fill(w69.begin(), w69.end(), 0.0f);
267 std::generate(w69.begin(), w69.end() - size_t(sparsity * w69.size()), std::ref(f32rng));
268 std::shuffle(w69.begin(), w69.end(), rng);
269 std::generate(w70.begin(), w70.end(), std::ref(f32rng));
270 std::fill(w71.begin(), w71.end(), 0.0f);
271 std::generate(w71.begin(), w71.end() - size_t(sparsity * w71.size()), std::ref(f32rng));
272 std::shuffle(w71.begin(), w71.end(), rng);
273 std::generate(w72.begin(), w72.end(), std::ref(f32rng));
274 std::generate(w73.begin(), w73.end(), std::ref(f32rng));
275 std::generate(w74.begin(), w74.end(), std::ref(f32rng));
276 std::fill(w75.begin(), w75.end(), 0.0f);
277 std::generate(w75.begin(), w75.end() - size_t(sparsity * w75.size()), std::ref(f32rng));
278 std::shuffle(w75.begin(), w75.end(), rng);
279 std::generate(w76.begin(), w76.end(), std::ref(f32rng));
280 std::fill(w77.begin(), w77.end(), 0.0f);
281 std::generate(w77.begin(), w77.end() - size_t(sparsity * w77.size()), std::ref(f32rng));
282 std::shuffle(w77.begin(), w77.end(), rng);
283 std::generate(w78.begin(), w78.end(), std::ref(f32rng));
284 std::generate(w79.begin(), w79.end(), std::ref(f32rng));
285 std::generate(w80.begin(), w80.end(), std::ref(f32rng));
286 std::fill(w81.begin(), w81.end(), 0.0f);
287 std::generate(w81.begin(), w81.end() - size_t(sparsity * w81.size()), std::ref(f32rng));
288 std::shuffle(w81.begin(), w81.end(), rng);
289 std::generate(w82.begin(), w82.end(), std::ref(f32rng));
290 std::fill(w83.begin(), w83.end(), 0.0f);
291 std::generate(w83.begin(), w83.end() - size_t(sparsity * w83.size()), std::ref(f32rng));
292 std::shuffle(w83.begin(), w83.end(), rng);
293 std::generate(w84.begin(), w84.end(), std::ref(f32rng));
294 std::generate(w85.begin(), w85.end(), std::ref(f32rng));
295 std::generate(w86.begin(), w86.end(), std::ref(f32rng));
296 std::fill(w87.begin(), w87.end(), 0.0f);
297 std::generate(w87.begin(), w87.end() - size_t(sparsity * w87.size()), std::ref(f32rng));
298 std::shuffle(w87.begin(), w87.end(), rng);
299 std::generate(w88.begin(), w88.end(), std::ref(f32rng));
300 std::fill(w89.begin(), w89.end(), 0.0f);
301 std::generate(w89.begin(), w89.end() - size_t(sparsity * w89.size()), std::ref(f32rng));
302 std::shuffle(w89.begin(), w89.end(), rng);
303 std::generate(w90.begin(), w90.end(), std::ref(f32rng));
304 std::generate(w91.begin(), w91.end(), std::ref(f32rng));
305 std::generate(w92.begin(), w92.end(), std::ref(f32rng));
306 std::fill(w93.begin(), w93.end(), 0.0f);
307 std::generate(w93.begin(), w93.end() - size_t(sparsity * w93.size()), std::ref(f32rng));
308 std::shuffle(w93.begin(), w93.end(), rng);
309 std::generate(w94.begin(), w94.end(), std::ref(f32rng));
310 std::fill(w95.begin(), w95.end(), 0.0f);
311 std::generate(w95.begin(), w95.end() - size_t(sparsity * w95.size()), std::ref(f32rng));
312 std::shuffle(w95.begin(), w95.end(), rng);
313 std::generate(w96.begin(), w96.end(), std::ref(f32rng));
314 std::generate(w97.begin(), w97.end(), std::ref(f32rng));
315 std::generate(w98.begin(), w98.end(), std::ref(f32rng));
316 std::fill(w99.begin(), w99.end(), 0.0f);
317 std::generate(w99.begin(), w99.end() - size_t(sparsity * w99.size()), std::ref(f32rng));
318 std::shuffle(w99.begin(), w99.end(), rng);
319 std::generate(w100.begin(), w100.end(), std::ref(f32rng));
320 std::fill(w101.begin(), w101.end(), 0.0f);
321 std::generate(w101.begin(), w101.end() - size_t(sparsity * w101.size()), std::ref(f32rng));
322 std::shuffle(w101.begin(), w101.end(), rng);
323 std::generate(w102.begin(), w102.end(), std::ref(f32rng));
324 std::generate(w103.begin(), w103.end(), std::ref(f32rng));
325 std::generate(w104.begin(), w104.end(), std::ref(f32rng));
326 std::fill(w105.begin(), w105.end(), 0.0f);
327 std::generate(w105.begin(), w105.end() - size_t(sparsity * w105.size()), std::ref(f32rng));
328 std::shuffle(w105.begin(), w105.end(), rng);
329 std::generate(w106.begin(), w106.end(), std::ref(f32rng));
330 std::fill(w107.begin(), w107.end(), 0.0f);
331 std::generate(w107.begin(), w107.end() - size_t(sparsity * w107.size()), std::ref(f32rng));
332 std::shuffle(w107.begin(), w107.end(), rng);
333 std::generate(w108.begin(), w108.end(), std::ref(f32rng));
334 std::generate(w109.begin(), w109.end(), std::ref(f32rng));
335 std::generate(w110.begin(), w110.end(), std::ref(f32rng));
336 std::fill(w111.begin(), w111.end(), 0.0f);
337 std::generate(w111.begin(), w111.end() - size_t(sparsity * w111.size()), std::ref(f32rng));
338 std::shuffle(w111.begin(), w111.end(), rng);
339 std::generate(w112.begin(), w112.end(), std::ref(f32rng));
340 std::fill(w113.begin(), w113.end(), 0.0f);
341 std::generate(w113.begin(), w113.end() - size_t(sparsity * w113.size()), std::ref(f32rng));
342 std::shuffle(w113.begin(), w113.end(), rng);
343 std::generate(w114.begin(), w114.end(), std::ref(f32rng));
344 std::generate(w115.begin(), w115.end(), std::ref(f32rng));
345 std::generate(w116.begin(), w116.end(), std::ref(f32rng));
346 std::fill(w117.begin(), w117.end(), 0.0f);
347 std::generate(w117.begin(), w117.end() - size_t(sparsity * w117.size()), std::ref(f32rng));
348 std::shuffle(w117.begin(), w117.end(), rng);
349 std::generate(w118.begin(), w118.end(), std::ref(f32rng));
350 std::fill(w119.begin(), w119.end(), 0.0f);
351 std::generate(w119.begin(), w119.end() - size_t(sparsity * w119.size()), std::ref(f32rng));
352 std::shuffle(w119.begin(), w119.end(), rng);
353 std::generate(w120.begin(), w120.end(), std::ref(f32rng));
354 std::generate(w121.begin(), w121.end(), std::ref(f32rng));
355 std::generate(w122.begin(), w122.end(), std::ref(f32rng));
356 std::fill(w123.begin(), w123.end(), 0.0f);
357 std::generate(w123.begin(), w123.end() - size_t(sparsity * w123.size()), std::ref(f32rng));
358 std::shuffle(w123.begin(), w123.end(), rng);
359 std::generate(w124.begin(), w124.end(), std::ref(f32rng));
360 std::fill(w125.begin(), w125.end(), 0.0f);
361 std::generate(w125.begin(), w125.end() - size_t(sparsity * w125.size()), std::ref(f32rng));
362 std::shuffle(w125.begin(), w125.end(), rng);
363 std::generate(w126.begin(), w126.end(), std::ref(f32rng));
364 std::generate(w127.begin(), w127.end(), std::ref(f32rng));
365 std::generate(w128.begin(), w128.end(), std::ref(f32rng));
366 std::fill(w129.begin(), w129.end(), 0.0f);
367 std::generate(w129.begin(), w129.end() - size_t(sparsity * w129.size()), std::ref(f32rng));
368 std::shuffle(w129.begin(), w129.end(), rng);
369 std::generate(w130.begin(), w130.end(), std::ref(f32rng));
370 std::fill(w131.begin(), w131.end(), 0.0f);
371 std::generate(w131.begin(), w131.end() - size_t(sparsity * w131.size()), std::ref(f32rng));
372 std::shuffle(w131.begin(), w131.end(), rng);
373 std::generate(w132.begin(), w132.end(), std::ref(f32rng));
374 std::generate(w133.begin(), w133.end(), std::ref(f32rng));
375 std::generate(w134.begin(), w134.end(), std::ref(f32rng));
376 std::fill(w135.begin(), w135.end(), 0.0f);
377 std::generate(w135.begin(), w135.end() - size_t(sparsity * w135.size()), std::ref(f32rng));
378 std::shuffle(w135.begin(), w135.end(), rng);
379 std::generate(w136.begin(), w136.end(), std::ref(f32rng));
380 std::fill(w137.begin(), w137.end(), 0.0f);
381 std::generate(w137.begin(), w137.end() - size_t(sparsity * w137.size()), std::ref(f32rng));
382 std::shuffle(w137.begin(), w137.end(), rng);
383 std::generate(w138.begin(), w138.end(), std::ref(f32rng));
384 std::generate(w139.begin(), w139.end(), std::ref(f32rng));
385 std::generate(w140.begin(), w140.end(), std::ref(f32rng));
386 std::fill(w141.begin(), w141.end(), 0.0f);
387 std::generate(w141.begin(), w141.end() - size_t(sparsity * w141.size()), std::ref(f32rng));
388 std::shuffle(w141.begin(), w141.end(), rng);
389 std::generate(w142.begin(), w142.end(), std::ref(f32rng));
390 std::fill(w143.begin(), w143.end(), 0.0f);
391 std::generate(w143.begin(), w143.end() - size_t(sparsity * w143.size()), std::ref(f32rng));
392 std::shuffle(w143.begin(), w143.end(), rng);
393 std::generate(w144.begin(), w144.end(), std::ref(f32rng));
394 std::generate(w145.begin(), w145.end(), std::ref(f32rng));
395 std::generate(w146.begin(), w146.end(), std::ref(f32rng));
396 std::fill(w147.begin(), w147.end(), 0.0f);
397 std::generate(w147.begin(), w147.end() - size_t(sparsity * w147.size()), std::ref(f32rng));
398 std::shuffle(w147.begin(), w147.end(), rng);
399 std::generate(w148.begin(), w148.end(), std::ref(f32rng));
400 std::fill(w149.begin(), w149.end(), 0.0f);
401 std::generate(w149.begin(), w149.end() - size_t(sparsity * w149.size()), std::ref(f32rng));
402 std::shuffle(w149.begin(), w149.end(), rng);
403 std::generate(w150.begin(), w150.end(), std::ref(f32rng));
404 std::generate(w151.begin(), w151.end(), std::ref(f32rng));
405 std::generate(w152.begin(), w152.end(), std::ref(f32rng));
406 std::fill(w153.begin(), w153.end(), 0.0f);
407 std::generate(w153.begin(), w153.end() - size_t(sparsity * w153.size()), std::ref(f32rng));
408 std::shuffle(w153.begin(), w153.end(), rng);
409 std::generate(w154.begin(), w154.end(), std::ref(f32rng));
410 std::fill(w155.begin(), w155.end(), 0.0f);
411 std::generate(w155.begin(), w155.end() - size_t(sparsity * w155.size()), std::ref(f32rng));
412 std::shuffle(w155.begin(), w155.end(), rng);
413 std::generate(w156.begin(), w156.end(), std::ref(f32rng));
414 std::generate(w157.begin(), w157.end(), std::ref(f32rng));
415 std::generate(w158.begin(), w158.end(), std::ref(f32rng));
416 std::fill(w159.begin(), w159.end(), 0.0f);
417 std::generate(w159.begin(), w159.end() - size_t(sparsity * w159.size()), std::ref(f32rng));
418 std::shuffle(w159.begin(), w159.end(), rng);
419 std::generate(w160.begin(), w160.end(), std::ref(f32rng));
420 std::fill(w161.begin(), w161.end(), 0.0f);
421 std::generate(w161.begin(), w161.end() - size_t(sparsity * w161.size()), std::ref(f32rng));
422 std::shuffle(w161.begin(), w161.end(), rng);
423 std::generate(w162.begin(), w162.end(), std::ref(f32rng));
424 std::generate(w163.begin(), w163.end(), std::ref(f32rng));
425 std::generate(w164.begin(), w164.end(), std::ref(f32rng));
426 std::fill(w165.begin(), w165.end(), 0.0f);
427 std::generate(w165.begin(), w165.end() - size_t(sparsity * w165.size()), std::ref(f32rng));
428 std::shuffle(w165.begin(), w165.end(), rng);
429 std::generate(w166.begin(), w166.end(), std::ref(f32rng));
430 std::fill(w167.begin(), w167.end(), 0.0f);
431 std::generate(w167.begin(), w167.end() - size_t(sparsity * w167.size()), std::ref(f32rng));
432 std::shuffle(w167.begin(), w167.end(), rng);
433 std::generate(w168.begin(), w168.end(), std::ref(f32rng));
434 std::fill(w169.begin(), w169.end(), 0.0f);
435 std::generate(w169.begin(), w169.end() - size_t(sparsity * w169.size()), std::ref(f32rng));
436 std::shuffle(w169.begin(), w169.end(), rng);
437 std::generate(w170.begin(), w170.end(), std::ref(f32rng));
438
439 ExecutionPlan operators;
440 xnn_status status;
441 xnn_code_cache code_cache;
442 #if XNN_PLATFORM_JIT
443 xnn_init_code_cache(&code_cache);
444 #endif
445 xnn_caches caches = { 0 };
446 caches.code_cache = &code_cache;
447
448 xnn_operator_t op0 = nullptr;
449 status = xnn_create_convolution2d_nchw_f32(
450 1 /* top padding */, 1 /* right padding */,
451 1 /* bottom padding */, 1 /* left padding */,
452 3 /* kernel height */, 3 /* kernel width */,
453 2 /* subsampling height */, 2 /* subsampling width */,
454 1 /* dilation_height */, 1 /* dilation_width */,
455 1 /* groups */,
456 3 /* input channels per group */,
457 32 /* output_channels_per_group */,
458 3 /* input pixel stride */,
459 32 /* output pixel stride */,
460 w65.data(), w66.data(),
461 0.0f /* output min */, 6.0f /* output max */,
462 XNN_FLAG_INPUT_NHWC /* flags */,
463 &caches,
464 &op0);
465 if (status != xnn_status_success) {
466 std::cerr << "failed to create operation #0" << std::endl;
467 return ExecutionPlan();
468 }
469 operators.emplace_back(op0, xnn_delete_operator);
470
471 xnn_operator_t op1 = nullptr;
472 status = xnn_create_convolution2d_nchw_f32(
473 1 /* top padding */, 1 /* right padding */,
474 1 /* bottom padding */, 1 /* left padding */,
475 3 /* kernel height */, 3 /* kernel width */,
476 1 /* subsampling height */, 1 /* subsampling width */,
477 1 /* dilation_height */, 1 /* dilation_width */,
478 32 /* groups */,
479 1 /* input channels per group */,
480 1 /* output_channels_per_group */,
481 32 /* input pixel stride */,
482 32 /* output pixel stride */,
483 w67.data(), w68.data(),
484 0.0f /* output min */, 6.0f /* output max */,
485 0 /* flags */,
486 &caches,
487 &op1);
488 if (status != xnn_status_success) {
489 std::cerr << "failed to create operation #1" << std::endl;
490 return ExecutionPlan();
491 }
492 operators.emplace_back(op1, xnn_delete_operator);
493
494 xnn_operator_t op2 = nullptr;
495 status = xnn_create_convolution2d_nchw_f32(
496 0 /* top padding */, 0 /* right padding */,
497 0 /* bottom padding */, 0 /* left padding */,
498 1 /* kernel height */, 1 /* kernel width */,
499 1 /* subsampling height */, 1 /* subsampling width */,
500 1 /* dilation_height */, 1 /* dilation_width */,
501 1 /* groups */,
502 32 /* input channels per group */,
503 16 /* output_channels_per_group */,
504 32 /* input pixel stride */,
505 16 /* output pixel stride */,
506 w69.data(), w70.data(),
507 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
508 0 /* flags */,
509 &caches,
510 &op2);
511 if (status != xnn_status_success) {
512 std::cerr << "failed to create operation #2" << std::endl;
513 return ExecutionPlan();
514 }
515 operators.emplace_back(op2, xnn_delete_operator);
516
517 xnn_operator_t op3 = nullptr;
518 status = xnn_create_convolution2d_nchw_f32(
519 0 /* top padding */, 0 /* right padding */,
520 0 /* bottom padding */, 0 /* left padding */,
521 1 /* kernel height */, 1 /* kernel width */,
522 1 /* subsampling height */, 1 /* subsampling width */,
523 1 /* dilation_height */, 1 /* dilation_width */,
524 1 /* groups */,
525 16 /* input channels per group */,
526 96 /* output_channels_per_group */,
527 16 /* input pixel stride */,
528 96 /* output pixel stride */,
529 w71.data(), w72.data(),
530 0.0f /* output min */, 6.0f /* output max */,
531 0 /* flags */,
532 &caches,
533 &op3);
534 if (status != xnn_status_success) {
535 std::cerr << "failed to create operation #3" << std::endl;
536 return ExecutionPlan();
537 }
538 operators.emplace_back(op3, xnn_delete_operator);
539
540 xnn_operator_t op4 = nullptr;
541 status = xnn_create_convolution2d_nchw_f32(
542 1 /* top padding */, 1 /* right padding */,
543 1 /* bottom padding */, 1 /* left padding */,
544 3 /* kernel height */, 3 /* kernel width */,
545 2 /* subsampling height */, 2 /* subsampling width */,
546 1 /* dilation_height */, 1 /* dilation_width */,
547 96 /* groups */,
548 1 /* input channels per group */,
549 1 /* output_channels_per_group */,
550 96 /* input pixel stride */,
551 96 /* output pixel stride */,
552 w73.data(), w74.data(),
553 0.0f /* output min */, 6.0f /* output max */,
554 0 /* flags */,
555 &caches,
556 &op4);
557 if (status != xnn_status_success) {
558 std::cerr << "failed to create operation #4" << std::endl;
559 return ExecutionPlan();
560 }
561 operators.emplace_back(op4, xnn_delete_operator);
562
563 xnn_operator_t op5 = nullptr;
564 status = xnn_create_convolution2d_nchw_f32(
565 0 /* top padding */, 0 /* right padding */,
566 0 /* bottom padding */, 0 /* left padding */,
567 1 /* kernel height */, 1 /* kernel width */,
568 1 /* subsampling height */, 1 /* subsampling width */,
569 1 /* dilation_height */, 1 /* dilation_width */,
570 1 /* groups */,
571 96 /* input channels per group */,
572 24 /* output_channels_per_group */,
573 96 /* input pixel stride */,
574 24 /* output pixel stride */,
575 w75.data(), w76.data(),
576 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
577 0 /* flags */,
578 &caches,
579 &op5);
580 if (status != xnn_status_success) {
581 std::cerr << "failed to create operation #5" << std::endl;
582 return ExecutionPlan();
583 }
584 operators.emplace_back(op5, xnn_delete_operator);
585
586 xnn_operator_t op6 = nullptr;
587 status = xnn_create_convolution2d_nchw_f32(
588 0 /* top padding */, 0 /* right padding */,
589 0 /* bottom padding */, 0 /* left padding */,
590 1 /* kernel height */, 1 /* kernel width */,
591 1 /* subsampling height */, 1 /* subsampling width */,
592 1 /* dilation_height */, 1 /* dilation_width */,
593 1 /* groups */,
594 24 /* input channels per group */,
595 144 /* output_channels_per_group */,
596 24 /* input pixel stride */,
597 144 /* output pixel stride */,
598 w77.data(), w78.data(),
599 0.0f /* output min */, 6.0f /* output max */,
600 0 /* flags */,
601 &caches,
602 &op6);
603 if (status != xnn_status_success) {
604 std::cerr << "failed to create operation #6" << std::endl;
605 return ExecutionPlan();
606 }
607 operators.emplace_back(op6, xnn_delete_operator);
608
609 xnn_operator_t op7 = nullptr;
610 status = xnn_create_convolution2d_nchw_f32(
611 1 /* top padding */, 1 /* right padding */,
612 1 /* bottom padding */, 1 /* left padding */,
613 3 /* kernel height */, 3 /* kernel width */,
614 1 /* subsampling height */, 1 /* subsampling width */,
615 1 /* dilation_height */, 1 /* dilation_width */,
616 144 /* groups */,
617 1 /* input channels per group */,
618 1 /* output_channels_per_group */,
619 144 /* input pixel stride */,
620 144 /* output pixel stride */,
621 w79.data(), w80.data(),
622 0.0f /* output min */, 6.0f /* output max */,
623 0 /* flags */,
624 &caches,
625 &op7);
626 if (status != xnn_status_success) {
627 std::cerr << "failed to create operation #7" << std::endl;
628 return ExecutionPlan();
629 }
630 operators.emplace_back(op7, xnn_delete_operator);
631
632 xnn_operator_t op8 = nullptr;
633 status = xnn_create_convolution2d_nchw_f32(
634 0 /* top padding */, 0 /* right padding */,
635 0 /* bottom padding */, 0 /* left padding */,
636 1 /* kernel height */, 1 /* kernel width */,
637 1 /* subsampling height */, 1 /* subsampling width */,
638 1 /* dilation_height */, 1 /* dilation_width */,
639 1 /* groups */,
640 144 /* input channels per group */,
641 24 /* output_channels_per_group */,
642 144 /* input pixel stride */,
643 24 /* output pixel stride */,
644 w81.data(), w82.data(),
645 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
646 0 /* flags */,
647 &caches,
648 &op8);
649 if (status != xnn_status_success) {
650 std::cerr << "failed to create operation #8" << std::endl;
651 return ExecutionPlan();
652 }
653 operators.emplace_back(op8, xnn_delete_operator);
654
655 xnn_operator_t op9 = nullptr;
656 status = xnn_create_add_nd_f32(
657 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
658 0 /* flags */,
659 &op9);
660 if (status != xnn_status_success) {
661 std::cerr << "failed to create operation #9" << std::endl;
662 return ExecutionPlan();
663 }
664 operators.emplace_back(op9, xnn_delete_operator);
665
666 xnn_operator_t op10 = nullptr;
667 status = xnn_create_convolution2d_nchw_f32(
668 0 /* top padding */, 0 /* right padding */,
669 0 /* bottom padding */, 0 /* left padding */,
670 1 /* kernel height */, 1 /* kernel width */,
671 1 /* subsampling height */, 1 /* subsampling width */,
672 1 /* dilation_height */, 1 /* dilation_width */,
673 1 /* groups */,
674 24 /* input channels per group */,
675 144 /* output_channels_per_group */,
676 24 /* input pixel stride */,
677 144 /* output pixel stride */,
678 w83.data(), w84.data(),
679 0.0f /* output min */, 6.0f /* output max */,
680 0 /* flags */,
681 &caches,
682 &op10);
683 if (status != xnn_status_success) {
684 std::cerr << "failed to create operation #10" << std::endl;
685 return ExecutionPlan();
686 }
687 operators.emplace_back(op10, xnn_delete_operator);
688
689 xnn_operator_t op11 = nullptr;
690 status = xnn_create_convolution2d_nchw_f32(
691 1 /* top padding */, 1 /* right padding */,
692 1 /* bottom padding */, 1 /* left padding */,
693 3 /* kernel height */, 3 /* kernel width */,
694 2 /* subsampling height */, 2 /* subsampling width */,
695 1 /* dilation_height */, 1 /* dilation_width */,
696 144 /* groups */,
697 1 /* input channels per group */,
698 1 /* output_channels_per_group */,
699 144 /* input pixel stride */,
700 144 /* output pixel stride */,
701 w85.data(), w86.data(),
702 0.0f /* output min */, 6.0f /* output max */,
703 0 /* flags */,
704 &caches,
705 &op11);
706 if (status != xnn_status_success) {
707 std::cerr << "failed to create operation #11" << std::endl;
708 return ExecutionPlan();
709 }
710 operators.emplace_back(op11, xnn_delete_operator);
711
712 xnn_operator_t op12 = nullptr;
713 status = xnn_create_convolution2d_nchw_f32(
714 0 /* top padding */, 0 /* right padding */,
715 0 /* bottom padding */, 0 /* left padding */,
716 1 /* kernel height */, 1 /* kernel width */,
717 1 /* subsampling height */, 1 /* subsampling width */,
718 1 /* dilation_height */, 1 /* dilation_width */,
719 1 /* groups */,
720 144 /* input channels per group */,
721 32 /* output_channels_per_group */,
722 144 /* input pixel stride */,
723 32 /* output pixel stride */,
724 w87.data(), w88.data(),
725 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
726 0 /* flags */,
727 &caches,
728 &op12);
729 if (status != xnn_status_success) {
730 std::cerr << "failed to create operation #12" << std::endl;
731 return ExecutionPlan();
732 }
733 operators.emplace_back(op12, xnn_delete_operator);
734
735 xnn_operator_t op13 = nullptr;
736 status = xnn_create_convolution2d_nchw_f32(
737 0 /* top padding */, 0 /* right padding */,
738 0 /* bottom padding */, 0 /* left padding */,
739 1 /* kernel height */, 1 /* kernel width */,
740 1 /* subsampling height */, 1 /* subsampling width */,
741 1 /* dilation_height */, 1 /* dilation_width */,
742 1 /* groups */,
743 32 /* input channels per group */,
744 192 /* output_channels_per_group */,
745 32 /* input pixel stride */,
746 192 /* output pixel stride */,
747 w89.data(), w90.data(),
748 0.0f /* output min */, 6.0f /* output max */,
749 0 /* flags */,
750 &caches,
751 &op13);
752 if (status != xnn_status_success) {
753 std::cerr << "failed to create operation #13" << std::endl;
754 return ExecutionPlan();
755 }
756 operators.emplace_back(op13, xnn_delete_operator);
757
758 xnn_operator_t op14 = nullptr;
759 status = xnn_create_convolution2d_nchw_f32(
760 1 /* top padding */, 1 /* right padding */,
761 1 /* bottom padding */, 1 /* left padding */,
762 3 /* kernel height */, 3 /* kernel width */,
763 1 /* subsampling height */, 1 /* subsampling width */,
764 1 /* dilation_height */, 1 /* dilation_width */,
765 192 /* groups */,
766 1 /* input channels per group */,
767 1 /* output_channels_per_group */,
768 192 /* input pixel stride */,
769 192 /* output pixel stride */,
770 w91.data(), w92.data(),
771 0.0f /* output min */, 6.0f /* output max */,
772 0 /* flags */,
773 &caches,
774 &op14);
775 if (status != xnn_status_success) {
776 std::cerr << "failed to create operation #14" << std::endl;
777 return ExecutionPlan();
778 }
779 operators.emplace_back(op14, xnn_delete_operator);
780
781 xnn_operator_t op15 = nullptr;
782 status = xnn_create_convolution2d_nchw_f32(
783 0 /* top padding */, 0 /* right padding */,
784 0 /* bottom padding */, 0 /* left padding */,
785 1 /* kernel height */, 1 /* kernel width */,
786 1 /* subsampling height */, 1 /* subsampling width */,
787 1 /* dilation_height */, 1 /* dilation_width */,
788 1 /* groups */,
789 192 /* input channels per group */,
790 32 /* output_channels_per_group */,
791 192 /* input pixel stride */,
792 32 /* output pixel stride */,
793 w93.data(), w94.data(),
794 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
795 0 /* flags */,
796 &caches,
797 &op15);
798 if (status != xnn_status_success) {
799 std::cerr << "failed to create operation #15" << std::endl;
800 return ExecutionPlan();
801 }
802 operators.emplace_back(op15, xnn_delete_operator);
803
804 xnn_operator_t op16 = 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 &op16);
809 if (status != xnn_status_success) {
810 std::cerr << "failed to create operation #16" << std::endl;
811 return ExecutionPlan();
812 }
813 operators.emplace_back(op16, xnn_delete_operator);
814
815 xnn_operator_t op17 = 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 32 /* input channels per group */,
824 192 /* output_channels_per_group */,
825 32 /* input pixel stride */,
826 192 /* output pixel stride */,
827 w95.data(), w96.data(),
828 0.0f /* output min */, 6.0f /* output max */,
829 0 /* flags */,
830 &caches,
831 &op17);
832 if (status != xnn_status_success) {
833 std::cerr << "failed to create operation #17" << std::endl;
834 return ExecutionPlan();
835 }
836 operators.emplace_back(op17, xnn_delete_operator);
837
838 xnn_operator_t op18 = nullptr;
839 status = xnn_create_convolution2d_nchw_f32(
840 1 /* top padding */, 1 /* right padding */,
841 1 /* bottom padding */, 1 /* left padding */,
842 3 /* kernel height */, 3 /* kernel width */,
843 1 /* subsampling height */, 1 /* subsampling width */,
844 1 /* dilation_height */, 1 /* dilation_width */,
845 192 /* groups */,
846 1 /* input channels per group */,
847 1 /* output_channels_per_group */,
848 192 /* input pixel stride */,
849 192 /* output pixel stride */,
850 w97.data(), w98.data(),
851 0.0f /* output min */, 6.0f /* output max */,
852 0 /* flags */,
853 &caches,
854 &op18);
855 if (status != xnn_status_success) {
856 std::cerr << "failed to create operation #18" << std::endl;
857 return ExecutionPlan();
858 }
859 operators.emplace_back(op18, xnn_delete_operator);
860
861 xnn_operator_t op19 = nullptr;
862 status = xnn_create_convolution2d_nchw_f32(
863 0 /* top padding */, 0 /* right padding */,
864 0 /* bottom padding */, 0 /* left padding */,
865 1 /* kernel height */, 1 /* kernel width */,
866 1 /* subsampling height */, 1 /* subsampling width */,
867 1 /* dilation_height */, 1 /* dilation_width */,
868 1 /* groups */,
869 192 /* input channels per group */,
870 32 /* output_channels_per_group */,
871 192 /* input pixel stride */,
872 32 /* output pixel stride */,
873 w99.data(), w100.data(),
874 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
875 0 /* flags */,
876 &caches,
877 &op19);
878 if (status != xnn_status_success) {
879 std::cerr << "failed to create operation #19" << std::endl;
880 return ExecutionPlan();
881 }
882 operators.emplace_back(op19, xnn_delete_operator);
883
884 xnn_operator_t op20 = nullptr;
885 status = xnn_create_add_nd_f32(
886 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
887 0 /* flags */,
888 &op20);
889 if (status != xnn_status_success) {
890 std::cerr << "failed to create operation #20" << std::endl;
891 return ExecutionPlan();
892 }
893 operators.emplace_back(op20, xnn_delete_operator);
894
895 xnn_operator_t op21 = nullptr;
896 status = xnn_create_convolution2d_nchw_f32(
897 0 /* top padding */, 0 /* right padding */,
898 0 /* bottom padding */, 0 /* left padding */,
899 1 /* kernel height */, 1 /* kernel width */,
900 1 /* subsampling height */, 1 /* subsampling width */,
901 1 /* dilation_height */, 1 /* dilation_width */,
902 1 /* groups */,
903 32 /* input channels per group */,
904 192 /* output_channels_per_group */,
905 32 /* input pixel stride */,
906 192 /* output pixel stride */,
907 w101.data(), w102.data(),
908 0.0f /* output min */, 6.0f /* output max */,
909 0 /* flags */,
910 &caches,
911 &op21);
912 if (status != xnn_status_success) {
913 std::cerr << "failed to create operation #21" << std::endl;
914 return ExecutionPlan();
915 }
916 operators.emplace_back(op21, xnn_delete_operator);
917
918 xnn_operator_t op22 = nullptr;
919 status = xnn_create_convolution2d_nchw_f32(
920 1 /* top padding */, 1 /* right padding */,
921 1 /* bottom padding */, 1 /* left padding */,
922 3 /* kernel height */, 3 /* kernel width */,
923 2 /* subsampling height */, 2 /* subsampling width */,
924 1 /* dilation_height */, 1 /* dilation_width */,
925 192 /* groups */,
926 1 /* input channels per group */,
927 1 /* output_channels_per_group */,
928 192 /* input pixel stride */,
929 192 /* output pixel stride */,
930 w103.data(), w104.data(),
931 0.0f /* output min */, 6.0f /* output max */,
932 0 /* flags */,
933 &caches,
934 &op22);
935 if (status != xnn_status_success) {
936 std::cerr << "failed to create operation #22" << std::endl;
937 return ExecutionPlan();
938 }
939 operators.emplace_back(op22, xnn_delete_operator);
940
941 xnn_operator_t op23 = nullptr;
942 status = xnn_create_convolution2d_nchw_f32(
943 0 /* top padding */, 0 /* right padding */,
944 0 /* bottom padding */, 0 /* left padding */,
945 1 /* kernel height */, 1 /* kernel width */,
946 1 /* subsampling height */, 1 /* subsampling width */,
947 1 /* dilation_height */, 1 /* dilation_width */,
948 1 /* groups */,
949 192 /* input channels per group */,
950 64 /* output_channels_per_group */,
951 192 /* input pixel stride */,
952 64 /* output pixel stride */,
953 w105.data(), w106.data(),
954 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
955 0 /* flags */,
956 &caches,
957 &op23);
958 if (status != xnn_status_success) {
959 std::cerr << "failed to create operation #23" << std::endl;
960 return ExecutionPlan();
961 }
962 operators.emplace_back(op23, xnn_delete_operator);
963
964 xnn_operator_t op24 = nullptr;
965 status = xnn_create_convolution2d_nchw_f32(
966 0 /* top padding */, 0 /* right padding */,
967 0 /* bottom padding */, 0 /* left padding */,
968 1 /* kernel height */, 1 /* kernel width */,
969 1 /* subsampling height */, 1 /* subsampling width */,
970 1 /* dilation_height */, 1 /* dilation_width */,
971 1 /* groups */,
972 64 /* input channels per group */,
973 384 /* output_channels_per_group */,
974 64 /* input pixel stride */,
975 384 /* output pixel stride */,
976 w107.data(), w108.data(),
977 0.0f /* output min */, 6.0f /* output max */,
978 0 /* flags */,
979 &caches,
980 &op24);
981 if (status != xnn_status_success) {
982 std::cerr << "failed to create operation #24" << std::endl;
983 return ExecutionPlan();
984 }
985 operators.emplace_back(op24, xnn_delete_operator);
986
987 xnn_operator_t op25 = nullptr;
988 status = xnn_create_convolution2d_nchw_f32(
989 1 /* top padding */, 1 /* right padding */,
990 1 /* bottom padding */, 1 /* left padding */,
991 3 /* kernel height */, 3 /* kernel width */,
992 1 /* subsampling height */, 1 /* subsampling width */,
993 1 /* dilation_height */, 1 /* dilation_width */,
994 384 /* groups */,
995 1 /* input channels per group */,
996 1 /* output_channels_per_group */,
997 384 /* input pixel stride */,
998 384 /* output pixel stride */,
999 w109.data(), w110.data(),
1000 0.0f /* output min */, 6.0f /* output max */,
1001 0 /* flags */,
1002 &caches,
1003 &op25);
1004 if (status != xnn_status_success) {
1005 std::cerr << "failed to create operation #25" << std::endl;
1006 return ExecutionPlan();
1007 }
1008 operators.emplace_back(op25, xnn_delete_operator);
1009
1010 xnn_operator_t op26 = nullptr;
1011 status = xnn_create_convolution2d_nchw_f32(
1012 0 /* top padding */, 0 /* right padding */,
1013 0 /* bottom padding */, 0 /* left padding */,
1014 1 /* kernel height */, 1 /* kernel width */,
1015 1 /* subsampling height */, 1 /* subsampling width */,
1016 1 /* dilation_height */, 1 /* dilation_width */,
1017 1 /* groups */,
1018 384 /* input channels per group */,
1019 64 /* output_channels_per_group */,
1020 384 /* input pixel stride */,
1021 64 /* output pixel stride */,
1022 w111.data(), w112.data(),
1023 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1024 0 /* flags */,
1025 &caches,
1026 &op26);
1027 if (status != xnn_status_success) {
1028 std::cerr << "failed to create operation #26" << std::endl;
1029 return ExecutionPlan();
1030 }
1031 operators.emplace_back(op26, xnn_delete_operator);
1032
1033 xnn_operator_t op27 = nullptr;
1034 status = xnn_create_add_nd_f32(
1035 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
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_convolution2d_nchw_f32(
1046 0 /* top padding */, 0 /* right padding */,
1047 0 /* bottom padding */, 0 /* left padding */,
1048 1 /* kernel height */, 1 /* kernel width */,
1049 1 /* subsampling height */, 1 /* subsampling width */,
1050 1 /* dilation_height */, 1 /* dilation_width */,
1051 1 /* groups */,
1052 64 /* input channels per group */,
1053 384 /* output_channels_per_group */,
1054 64 /* input pixel stride */,
1055 384 /* output pixel stride */,
1056 w113.data(), w114.data(),
1057 0.0f /* output min */, 6.0f /* output max */,
1058 0 /* flags */,
1059 &caches,
1060 &op28);
1061 if (status != xnn_status_success) {
1062 std::cerr << "failed to create operation #28" << std::endl;
1063 return ExecutionPlan();
1064 }
1065 operators.emplace_back(op28, xnn_delete_operator);
1066
1067 xnn_operator_t op29 = nullptr;
1068 status = xnn_create_convolution2d_nchw_f32(
1069 1 /* top padding */, 1 /* right padding */,
1070 1 /* bottom padding */, 1 /* left padding */,
1071 3 /* kernel height */, 3 /* kernel width */,
1072 1 /* subsampling height */, 1 /* subsampling width */,
1073 1 /* dilation_height */, 1 /* dilation_width */,
1074 384 /* groups */,
1075 1 /* input channels per group */,
1076 1 /* output_channels_per_group */,
1077 384 /* input pixel stride */,
1078 384 /* output pixel stride */,
1079 w115.data(), w116.data(),
1080 0.0f /* output min */, 6.0f /* output max */,
1081 0 /* flags */,
1082 &caches,
1083 &op29);
1084 if (status != xnn_status_success) {
1085 std::cerr << "failed to create operation #29" << std::endl;
1086 return ExecutionPlan();
1087 }
1088 operators.emplace_back(op29, xnn_delete_operator);
1089
1090 xnn_operator_t op30 = nullptr;
1091 status = xnn_create_convolution2d_nchw_f32(
1092 0 /* top padding */, 0 /* right padding */,
1093 0 /* bottom padding */, 0 /* left padding */,
1094 1 /* kernel height */, 1 /* kernel width */,
1095 1 /* subsampling height */, 1 /* subsampling width */,
1096 1 /* dilation_height */, 1 /* dilation_width */,
1097 1 /* groups */,
1098 384 /* input channels per group */,
1099 64 /* output_channels_per_group */,
1100 384 /* input pixel stride */,
1101 64 /* output pixel stride */,
1102 w117.data(), w118.data(),
1103 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1104 0 /* flags */,
1105 &caches,
1106 &op30);
1107 if (status != xnn_status_success) {
1108 std::cerr << "failed to create operation #30" << std::endl;
1109 return ExecutionPlan();
1110 }
1111 operators.emplace_back(op30, xnn_delete_operator);
1112
1113 xnn_operator_t op31 = nullptr;
1114 status = xnn_create_add_nd_f32(
1115 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1116 0 /* flags */,
1117 &op31);
1118 if (status != xnn_status_success) {
1119 std::cerr << "failed to create operation #31" << std::endl;
1120 return ExecutionPlan();
1121 }
1122 operators.emplace_back(op31, xnn_delete_operator);
1123
1124 xnn_operator_t op32 = nullptr;
1125 status = xnn_create_convolution2d_nchw_f32(
1126 0 /* top padding */, 0 /* right padding */,
1127 0 /* bottom padding */, 0 /* left padding */,
1128 1 /* kernel height */, 1 /* kernel width */,
1129 1 /* subsampling height */, 1 /* subsampling width */,
1130 1 /* dilation_height */, 1 /* dilation_width */,
1131 1 /* groups */,
1132 64 /* input channels per group */,
1133 384 /* output_channels_per_group */,
1134 64 /* input pixel stride */,
1135 384 /* output pixel stride */,
1136 w119.data(), w120.data(),
1137 0.0f /* output min */, 6.0f /* output max */,
1138 0 /* flags */,
1139 &caches,
1140 &op32);
1141 if (status != xnn_status_success) {
1142 std::cerr << "failed to create operation #32" << std::endl;
1143 return ExecutionPlan();
1144 }
1145 operators.emplace_back(op32, xnn_delete_operator);
1146
1147 xnn_operator_t op33 = nullptr;
1148 status = xnn_create_convolution2d_nchw_f32(
1149 1 /* top padding */, 1 /* right padding */,
1150 1 /* bottom padding */, 1 /* left padding */,
1151 3 /* kernel height */, 3 /* kernel width */,
1152 1 /* subsampling height */, 1 /* subsampling width */,
1153 1 /* dilation_height */, 1 /* dilation_width */,
1154 384 /* groups */,
1155 1 /* input channels per group */,
1156 1 /* output_channels_per_group */,
1157 384 /* input pixel stride */,
1158 384 /* output pixel stride */,
1159 w121.data(), w122.data(),
1160 0.0f /* output min */, 6.0f /* output max */,
1161 0 /* flags */,
1162 &caches,
1163 &op33);
1164 if (status != xnn_status_success) {
1165 std::cerr << "failed to create operation #33" << std::endl;
1166 return ExecutionPlan();
1167 }
1168 operators.emplace_back(op33, xnn_delete_operator);
1169
1170 xnn_operator_t op34 = nullptr;
1171 status = xnn_create_convolution2d_nchw_f32(
1172 0 /* top padding */, 0 /* right padding */,
1173 0 /* bottom padding */, 0 /* left padding */,
1174 1 /* kernel height */, 1 /* kernel width */,
1175 1 /* subsampling height */, 1 /* subsampling width */,
1176 1 /* dilation_height */, 1 /* dilation_width */,
1177 1 /* groups */,
1178 384 /* input channels per group */,
1179 64 /* output_channels_per_group */,
1180 384 /* input pixel stride */,
1181 64 /* output pixel stride */,
1182 w123.data(), w124.data(),
1183 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1184 0 /* flags */,
1185 &caches,
1186 &op34);
1187 if (status != xnn_status_success) {
1188 std::cerr << "failed to create operation #34" << std::endl;
1189 return ExecutionPlan();
1190 }
1191 operators.emplace_back(op34, xnn_delete_operator);
1192
1193 xnn_operator_t op35 = nullptr;
1194 status = xnn_create_add_nd_f32(
1195 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1196 0 /* flags */,
1197 &op35);
1198 if (status != xnn_status_success) {
1199 std::cerr << "failed to create operation #35" << std::endl;
1200 return ExecutionPlan();
1201 }
1202 operators.emplace_back(op35, xnn_delete_operator);
1203
1204 xnn_operator_t op36 = nullptr;
1205 status = xnn_create_convolution2d_nchw_f32(
1206 0 /* top padding */, 0 /* right padding */,
1207 0 /* bottom padding */, 0 /* left padding */,
1208 1 /* kernel height */, 1 /* kernel width */,
1209 1 /* subsampling height */, 1 /* subsampling width */,
1210 1 /* dilation_height */, 1 /* dilation_width */,
1211 1 /* groups */,
1212 64 /* input channels per group */,
1213 384 /* output_channels_per_group */,
1214 64 /* input pixel stride */,
1215 384 /* output pixel stride */,
1216 w125.data(), w126.data(),
1217 0.0f /* output min */, 6.0f /* output max */,
1218 0 /* flags */,
1219 &caches,
1220 &op36);
1221 if (status != xnn_status_success) {
1222 std::cerr << "failed to create operation #36" << std::endl;
1223 return ExecutionPlan();
1224 }
1225 operators.emplace_back(op36, xnn_delete_operator);
1226
1227 xnn_operator_t op37 = nullptr;
1228 status = xnn_create_convolution2d_nchw_f32(
1229 1 /* top padding */, 1 /* right padding */,
1230 1 /* bottom padding */, 1 /* left padding */,
1231 3 /* kernel height */, 3 /* kernel width */,
1232 1 /* subsampling height */, 1 /* subsampling width */,
1233 1 /* dilation_height */, 1 /* dilation_width */,
1234 384 /* groups */,
1235 1 /* input channels per group */,
1236 1 /* output_channels_per_group */,
1237 384 /* input pixel stride */,
1238 384 /* output pixel stride */,
1239 w127.data(), w128.data(),
1240 0.0f /* output min */, 6.0f /* output max */,
1241 0 /* flags */,
1242 &caches,
1243 &op37);
1244 if (status != xnn_status_success) {
1245 std::cerr << "failed to create operation #37" << std::endl;
1246 return ExecutionPlan();
1247 }
1248 operators.emplace_back(op37, xnn_delete_operator);
1249
1250 xnn_operator_t op38 = nullptr;
1251 status = xnn_create_convolution2d_nchw_f32(
1252 0 /* top padding */, 0 /* right padding */,
1253 0 /* bottom padding */, 0 /* left padding */,
1254 1 /* kernel height */, 1 /* kernel width */,
1255 1 /* subsampling height */, 1 /* subsampling width */,
1256 1 /* dilation_height */, 1 /* dilation_width */,
1257 1 /* groups */,
1258 384 /* input channels per group */,
1259 96 /* output_channels_per_group */,
1260 384 /* input pixel stride */,
1261 96 /* output pixel stride */,
1262 w129.data(), w130.data(),
1263 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1264 0 /* flags */,
1265 &caches,
1266 &op38);
1267 if (status != xnn_status_success) {
1268 std::cerr << "failed to create operation #38" << std::endl;
1269 return ExecutionPlan();
1270 }
1271 operators.emplace_back(op38, xnn_delete_operator);
1272
1273 xnn_operator_t op39 = nullptr;
1274 status = xnn_create_convolution2d_nchw_f32(
1275 0 /* top padding */, 0 /* right padding */,
1276 0 /* bottom padding */, 0 /* left padding */,
1277 1 /* kernel height */, 1 /* kernel width */,
1278 1 /* subsampling height */, 1 /* subsampling width */,
1279 1 /* dilation_height */, 1 /* dilation_width */,
1280 1 /* groups */,
1281 96 /* input channels per group */,
1282 576 /* output_channels_per_group */,
1283 96 /* input pixel stride */,
1284 576 /* output pixel stride */,
1285 w131.data(), w132.data(),
1286 0.0f /* output min */, 6.0f /* output max */,
1287 0 /* flags */,
1288 &caches,
1289 &op39);
1290 if (status != xnn_status_success) {
1291 std::cerr << "failed to create operation #39" << std::endl;
1292 return ExecutionPlan();
1293 }
1294 operators.emplace_back(op39, xnn_delete_operator);
1295
1296 xnn_operator_t op40 = nullptr;
1297 status = xnn_create_convolution2d_nchw_f32(
1298 1 /* top padding */, 1 /* right padding */,
1299 1 /* bottom padding */, 1 /* left padding */,
1300 3 /* kernel height */, 3 /* kernel width */,
1301 1 /* subsampling height */, 1 /* subsampling width */,
1302 1 /* dilation_height */, 1 /* dilation_width */,
1303 576 /* groups */,
1304 1 /* input channels per group */,
1305 1 /* output_channels_per_group */,
1306 576 /* input pixel stride */,
1307 576 /* output pixel stride */,
1308 w133.data(), w134.data(),
1309 0.0f /* output min */, 6.0f /* output max */,
1310 0 /* flags */,
1311 &caches,
1312 &op40);
1313 if (status != xnn_status_success) {
1314 std::cerr << "failed to create operation #40" << std::endl;
1315 return ExecutionPlan();
1316 }
1317 operators.emplace_back(op40, xnn_delete_operator);
1318
1319 xnn_operator_t op41 = nullptr;
1320 status = xnn_create_convolution2d_nchw_f32(
1321 0 /* top padding */, 0 /* right padding */,
1322 0 /* bottom padding */, 0 /* left padding */,
1323 1 /* kernel height */, 1 /* kernel width */,
1324 1 /* subsampling height */, 1 /* subsampling width */,
1325 1 /* dilation_height */, 1 /* dilation_width */,
1326 1 /* groups */,
1327 576 /* input channels per group */,
1328 96 /* output_channels_per_group */,
1329 576 /* input pixel stride */,
1330 96 /* output pixel stride */,
1331 w135.data(), w136.data(),
1332 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1333 0 /* flags */,
1334 &caches,
1335 &op41);
1336 if (status != xnn_status_success) {
1337 std::cerr << "failed to create operation #41" << std::endl;
1338 return ExecutionPlan();
1339 }
1340 operators.emplace_back(op41, xnn_delete_operator);
1341
1342 xnn_operator_t op42 = nullptr;
1343 status = xnn_create_add_nd_f32(
1344 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1345 0 /* flags */,
1346 &op42);
1347 if (status != xnn_status_success) {
1348 std::cerr << "failed to create operation #42" << std::endl;
1349 return ExecutionPlan();
1350 }
1351 operators.emplace_back(op42, xnn_delete_operator);
1352
1353 xnn_operator_t op43 = nullptr;
1354 status = xnn_create_convolution2d_nchw_f32(
1355 0 /* top padding */, 0 /* right padding */,
1356 0 /* bottom padding */, 0 /* left padding */,
1357 1 /* kernel height */, 1 /* kernel width */,
1358 1 /* subsampling height */, 1 /* subsampling width */,
1359 1 /* dilation_height */, 1 /* dilation_width */,
1360 1 /* groups */,
1361 96 /* input channels per group */,
1362 576 /* output_channels_per_group */,
1363 96 /* input pixel stride */,
1364 576 /* output pixel stride */,
1365 w137.data(), w138.data(),
1366 0.0f /* output min */, 6.0f /* output max */,
1367 0 /* flags */,
1368 &caches,
1369 &op43);
1370 if (status != xnn_status_success) {
1371 std::cerr << "failed to create operation #43" << std::endl;
1372 return ExecutionPlan();
1373 }
1374 operators.emplace_back(op43, xnn_delete_operator);
1375
1376 xnn_operator_t op44 = nullptr;
1377 status = xnn_create_convolution2d_nchw_f32(
1378 1 /* top padding */, 1 /* right padding */,
1379 1 /* bottom padding */, 1 /* left padding */,
1380 3 /* kernel height */, 3 /* kernel width */,
1381 1 /* subsampling height */, 1 /* subsampling width */,
1382 1 /* dilation_height */, 1 /* dilation_width */,
1383 576 /* groups */,
1384 1 /* input channels per group */,
1385 1 /* output_channels_per_group */,
1386 576 /* input pixel stride */,
1387 576 /* output pixel stride */,
1388 w139.data(), w140.data(),
1389 0.0f /* output min */, 6.0f /* output max */,
1390 0 /* flags */,
1391 &caches,
1392 &op44);
1393 if (status != xnn_status_success) {
1394 std::cerr << "failed to create operation #44" << std::endl;
1395 return ExecutionPlan();
1396 }
1397 operators.emplace_back(op44, xnn_delete_operator);
1398
1399 xnn_operator_t op45 = nullptr;
1400 status = xnn_create_convolution2d_nchw_f32(
1401 0 /* top padding */, 0 /* right padding */,
1402 0 /* bottom padding */, 0 /* left padding */,
1403 1 /* kernel height */, 1 /* kernel width */,
1404 1 /* subsampling height */, 1 /* subsampling width */,
1405 1 /* dilation_height */, 1 /* dilation_width */,
1406 1 /* groups */,
1407 576 /* input channels per group */,
1408 96 /* output_channels_per_group */,
1409 576 /* input pixel stride */,
1410 96 /* output pixel stride */,
1411 w141.data(), w142.data(),
1412 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1413 0 /* flags */,
1414 &caches,
1415 &op45);
1416 if (status != xnn_status_success) {
1417 std::cerr << "failed to create operation #45" << std::endl;
1418 return ExecutionPlan();
1419 }
1420 operators.emplace_back(op45, xnn_delete_operator);
1421
1422 xnn_operator_t op46 = nullptr;
1423 status = xnn_create_add_nd_f32(
1424 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1425 0 /* flags */,
1426 &op46);
1427 if (status != xnn_status_success) {
1428 std::cerr << "failed to create operation #46" << std::endl;
1429 return ExecutionPlan();
1430 }
1431 operators.emplace_back(op46, xnn_delete_operator);
1432
1433 xnn_operator_t op47 = nullptr;
1434 status = xnn_create_convolution2d_nchw_f32(
1435 0 /* top padding */, 0 /* right padding */,
1436 0 /* bottom padding */, 0 /* left padding */,
1437 1 /* kernel height */, 1 /* kernel width */,
1438 1 /* subsampling height */, 1 /* subsampling width */,
1439 1 /* dilation_height */, 1 /* dilation_width */,
1440 1 /* groups */,
1441 96 /* input channels per group */,
1442 576 /* output_channels_per_group */,
1443 96 /* input pixel stride */,
1444 576 /* output pixel stride */,
1445 w143.data(), w144.data(),
1446 0.0f /* output min */, 6.0f /* output max */,
1447 0 /* flags */,
1448 &caches,
1449 &op47);
1450 if (status != xnn_status_success) {
1451 std::cerr << "failed to create operation #47" << std::endl;
1452 return ExecutionPlan();
1453 }
1454 operators.emplace_back(op47, xnn_delete_operator);
1455
1456 xnn_operator_t op48 = nullptr;
1457 status = xnn_create_convolution2d_nchw_f32(
1458 1 /* top padding */, 1 /* right padding */,
1459 1 /* bottom padding */, 1 /* left padding */,
1460 3 /* kernel height */, 3 /* kernel width */,
1461 2 /* subsampling height */, 2 /* subsampling width */,
1462 1 /* dilation_height */, 1 /* dilation_width */,
1463 576 /* groups */,
1464 1 /* input channels per group */,
1465 1 /* output_channels_per_group */,
1466 576 /* input pixel stride */,
1467 576 /* output pixel stride */,
1468 w145.data(), w146.data(),
1469 0.0f /* output min */, 6.0f /* output max */,
1470 0 /* flags */,
1471 &caches,
1472 &op48);
1473 if (status != xnn_status_success) {
1474 std::cerr << "failed to create operation #48" << std::endl;
1475 return ExecutionPlan();
1476 }
1477 operators.emplace_back(op48, xnn_delete_operator);
1478
1479 xnn_operator_t op49 = nullptr;
1480 status = xnn_create_convolution2d_nchw_f32(
1481 0 /* top padding */, 0 /* right padding */,
1482 0 /* bottom padding */, 0 /* left padding */,
1483 1 /* kernel height */, 1 /* kernel width */,
1484 1 /* subsampling height */, 1 /* subsampling width */,
1485 1 /* dilation_height */, 1 /* dilation_width */,
1486 1 /* groups */,
1487 576 /* input channels per group */,
1488 160 /* output_channels_per_group */,
1489 576 /* input pixel stride */,
1490 160 /* output pixel stride */,
1491 w147.data(), w148.data(),
1492 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1493 0 /* flags */,
1494 &caches,
1495 &op49);
1496 if (status != xnn_status_success) {
1497 std::cerr << "failed to create operation #49" << std::endl;
1498 return ExecutionPlan();
1499 }
1500 operators.emplace_back(op49, xnn_delete_operator);
1501
1502 xnn_operator_t op50 = nullptr;
1503 status = xnn_create_convolution2d_nchw_f32(
1504 0 /* top padding */, 0 /* right padding */,
1505 0 /* bottom padding */, 0 /* left padding */,
1506 1 /* kernel height */, 1 /* kernel width */,
1507 1 /* subsampling height */, 1 /* subsampling width */,
1508 1 /* dilation_height */, 1 /* dilation_width */,
1509 1 /* groups */,
1510 160 /* input channels per group */,
1511 960 /* output_channels_per_group */,
1512 160 /* input pixel stride */,
1513 960 /* output pixel stride */,
1514 w149.data(), w150.data(),
1515 0.0f /* output min */, 6.0f /* output max */,
1516 0 /* flags */,
1517 &caches,
1518 &op50);
1519 if (status != xnn_status_success) {
1520 std::cerr << "failed to create operation #50" << std::endl;
1521 return ExecutionPlan();
1522 }
1523 operators.emplace_back(op50, xnn_delete_operator);
1524
1525 xnn_operator_t op51 = nullptr;
1526 status = xnn_create_convolution2d_nchw_f32(
1527 1 /* top padding */, 1 /* right padding */,
1528 1 /* bottom padding */, 1 /* left padding */,
1529 3 /* kernel height */, 3 /* kernel width */,
1530 1 /* subsampling height */, 1 /* subsampling width */,
1531 1 /* dilation_height */, 1 /* dilation_width */,
1532 960 /* groups */,
1533 1 /* input channels per group */,
1534 1 /* output_channels_per_group */,
1535 960 /* input pixel stride */,
1536 960 /* output pixel stride */,
1537 w151.data(), w152.data(),
1538 0.0f /* output min */, 6.0f /* output max */,
1539 0 /* flags */,
1540 &caches,
1541 &op51);
1542 if (status != xnn_status_success) {
1543 std::cerr << "failed to create operation #51" << std::endl;
1544 return ExecutionPlan();
1545 }
1546 operators.emplace_back(op51, xnn_delete_operator);
1547
1548 xnn_operator_t op52 = nullptr;
1549 status = xnn_create_convolution2d_nchw_f32(
1550 0 /* top padding */, 0 /* right padding */,
1551 0 /* bottom padding */, 0 /* left padding */,
1552 1 /* kernel height */, 1 /* kernel width */,
1553 1 /* subsampling height */, 1 /* subsampling width */,
1554 1 /* dilation_height */, 1 /* dilation_width */,
1555 1 /* groups */,
1556 960 /* input channels per group */,
1557 160 /* output_channels_per_group */,
1558 960 /* input pixel stride */,
1559 160 /* output pixel stride */,
1560 w153.data(), w154.data(),
1561 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1562 0 /* flags */,
1563 &caches,
1564 &op52);
1565 if (status != xnn_status_success) {
1566 std::cerr << "failed to create operation #52" << std::endl;
1567 return ExecutionPlan();
1568 }
1569 operators.emplace_back(op52, xnn_delete_operator);
1570
1571 xnn_operator_t op53 = nullptr;
1572 status = xnn_create_add_nd_f32(
1573 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1574 0 /* flags */,
1575 &op53);
1576 if (status != xnn_status_success) {
1577 std::cerr << "failed to create operation #53" << std::endl;
1578 return ExecutionPlan();
1579 }
1580 operators.emplace_back(op53, xnn_delete_operator);
1581
1582 xnn_operator_t op54 = nullptr;
1583 status = xnn_create_convolution2d_nchw_f32(
1584 0 /* top padding */, 0 /* right padding */,
1585 0 /* bottom padding */, 0 /* left padding */,
1586 1 /* kernel height */, 1 /* kernel width */,
1587 1 /* subsampling height */, 1 /* subsampling width */,
1588 1 /* dilation_height */, 1 /* dilation_width */,
1589 1 /* groups */,
1590 160 /* input channels per group */,
1591 960 /* output_channels_per_group */,
1592 160 /* input pixel stride */,
1593 960 /* output pixel stride */,
1594 w155.data(), w156.data(),
1595 0.0f /* output min */, 6.0f /* output max */,
1596 0 /* flags */,
1597 &caches,
1598 &op54);
1599 if (status != xnn_status_success) {
1600 std::cerr << "failed to create operation #54" << std::endl;
1601 return ExecutionPlan();
1602 }
1603 operators.emplace_back(op54, xnn_delete_operator);
1604
1605 xnn_operator_t op55 = nullptr;
1606 status = xnn_create_convolution2d_nchw_f32(
1607 1 /* top padding */, 1 /* right padding */,
1608 1 /* bottom padding */, 1 /* left padding */,
1609 3 /* kernel height */, 3 /* kernel width */,
1610 1 /* subsampling height */, 1 /* subsampling width */,
1611 1 /* dilation_height */, 1 /* dilation_width */,
1612 960 /* groups */,
1613 1 /* input channels per group */,
1614 1 /* output_channels_per_group */,
1615 960 /* input pixel stride */,
1616 960 /* output pixel stride */,
1617 w157.data(), w158.data(),
1618 0.0f /* output min */, 6.0f /* output max */,
1619 0 /* flags */,
1620 &caches,
1621 &op55);
1622 if (status != xnn_status_success) {
1623 std::cerr << "failed to create operation #55" << std::endl;
1624 return ExecutionPlan();
1625 }
1626 operators.emplace_back(op55, xnn_delete_operator);
1627
1628 xnn_operator_t op56 = nullptr;
1629 status = xnn_create_convolution2d_nchw_f32(
1630 0 /* top padding */, 0 /* right padding */,
1631 0 /* bottom padding */, 0 /* left padding */,
1632 1 /* kernel height */, 1 /* kernel width */,
1633 1 /* subsampling height */, 1 /* subsampling width */,
1634 1 /* dilation_height */, 1 /* dilation_width */,
1635 1 /* groups */,
1636 960 /* input channels per group */,
1637 160 /* output_channels_per_group */,
1638 960 /* input pixel stride */,
1639 160 /* output pixel stride */,
1640 w159.data(), w160.data(),
1641 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1642 0 /* flags */,
1643 &caches,
1644 &op56);
1645 if (status != xnn_status_success) {
1646 std::cerr << "failed to create operation #56" << std::endl;
1647 return ExecutionPlan();
1648 }
1649 operators.emplace_back(op56, xnn_delete_operator);
1650
1651 xnn_operator_t op57 = nullptr;
1652 status = xnn_create_add_nd_f32(
1653 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1654 0 /* flags */,
1655 &op57);
1656 if (status != xnn_status_success) {
1657 std::cerr << "failed to create operation #57" << std::endl;
1658 return ExecutionPlan();
1659 }
1660 operators.emplace_back(op57, xnn_delete_operator);
1661
1662 xnn_operator_t op58 = nullptr;
1663 status = xnn_create_convolution2d_nchw_f32(
1664 0 /* top padding */, 0 /* right padding */,
1665 0 /* bottom padding */, 0 /* left padding */,
1666 1 /* kernel height */, 1 /* kernel width */,
1667 1 /* subsampling height */, 1 /* subsampling width */,
1668 1 /* dilation_height */, 1 /* dilation_width */,
1669 1 /* groups */,
1670 160 /* input channels per group */,
1671 960 /* output_channels_per_group */,
1672 160 /* input pixel stride */,
1673 960 /* output pixel stride */,
1674 w161.data(), w162.data(),
1675 0.0f /* output min */, 6.0f /* output max */,
1676 0 /* flags */,
1677 &caches,
1678 &op58);
1679 if (status != xnn_status_success) {
1680 std::cerr << "failed to create operation #58" << std::endl;
1681 return ExecutionPlan();
1682 }
1683 operators.emplace_back(op58, xnn_delete_operator);
1684
1685 xnn_operator_t op59 = nullptr;
1686 status = xnn_create_convolution2d_nchw_f32(
1687 1 /* top padding */, 1 /* right padding */,
1688 1 /* bottom padding */, 1 /* left padding */,
1689 3 /* kernel height */, 3 /* kernel width */,
1690 1 /* subsampling height */, 1 /* subsampling width */,
1691 1 /* dilation_height */, 1 /* dilation_width */,
1692 960 /* groups */,
1693 1 /* input channels per group */,
1694 1 /* output_channels_per_group */,
1695 960 /* input pixel stride */,
1696 960 /* output pixel stride */,
1697 w163.data(), w164.data(),
1698 0.0f /* output min */, 6.0f /* output max */,
1699 0 /* flags */,
1700 &caches,
1701 &op59);
1702 if (status != xnn_status_success) {
1703 std::cerr << "failed to create operation #59" << std::endl;
1704 return ExecutionPlan();
1705 }
1706 operators.emplace_back(op59, xnn_delete_operator);
1707
1708 xnn_operator_t op60 = nullptr;
1709 status = xnn_create_convolution2d_nchw_f32(
1710 0 /* top padding */, 0 /* right padding */,
1711 0 /* bottom padding */, 0 /* left padding */,
1712 1 /* kernel height */, 1 /* kernel width */,
1713 1 /* subsampling height */, 1 /* subsampling width */,
1714 1 /* dilation_height */, 1 /* dilation_width */,
1715 1 /* groups */,
1716 960 /* input channels per group */,
1717 320 /* output_channels_per_group */,
1718 960 /* input pixel stride */,
1719 320 /* output pixel stride */,
1720 w165.data(), w166.data(),
1721 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1722 0 /* flags */,
1723 &caches,
1724 &op60);
1725 if (status != xnn_status_success) {
1726 std::cerr << "failed to create operation #60" << std::endl;
1727 return ExecutionPlan();
1728 }
1729 operators.emplace_back(op60, xnn_delete_operator);
1730
1731 xnn_operator_t op61 = nullptr;
1732 status = xnn_create_convolution2d_nchw_f32(
1733 0 /* top padding */, 0 /* right padding */,
1734 0 /* bottom padding */, 0 /* left padding */,
1735 1 /* kernel height */, 1 /* kernel width */,
1736 1 /* subsampling height */, 1 /* subsampling width */,
1737 1 /* dilation_height */, 1 /* dilation_width */,
1738 1 /* groups */,
1739 320 /* input channels per group */,
1740 1280 /* output_channels_per_group */,
1741 320 /* input pixel stride */,
1742 1280 /* output pixel stride */,
1743 w167.data(), w168.data(),
1744 0.0f /* output min */, 6.0f /* output max */,
1745 0 /* flags */,
1746 &caches,
1747 &op61);
1748 if (status != xnn_status_success) {
1749 std::cerr << "failed to create operation #61" << std::endl;
1750 return ExecutionPlan();
1751 }
1752 operators.emplace_back(op61, xnn_delete_operator);
1753
1754 xnn_operator_t op62 = nullptr;
1755 status = xnn_create_global_average_pooling_ncw_f32(
1756 1280 /* channels */,
1757 -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
1758 0 /* flags */,
1759 &op62);
1760 if (status != xnn_status_success) {
1761 std::cerr << "failed to create operation #62" << std::endl;
1762 return ExecutionPlan();
1763 }
1764 operators.emplace_back(op62, xnn_delete_operator);
1765
1766 xnn_operator_t op63 = nullptr;
1767 status = xnn_create_convolution2d_nhwc_f32(
1768 0 /* top padding */, 0 /* right padding */,
1769 0 /* bottom padding */, 0 /* left padding */,
1770 1 /* kernel height */, 1 /* kernel width */,
1771 1 /* subsampling height */, 1 /* subsampling width */,
1772 1 /* dilation_height */, 1 /* dilation_width */,
1773 1 /* groups */,
1774 1280 /* input channels per group */,
1775 1001 /* output_channels_per_group */,
1776 1280 /* input pixel stride */,
1777 1001 /* output pixel stride */,
1778 w169.data(), w170.data(),
1779 -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
1780 0 /* flags */,
1781 &caches,
1782 &op63);
1783 if (status != xnn_status_success) {
1784 std::cerr << "failed to create operation #63" << std::endl;
1785 return ExecutionPlan();
1786 }
1787 operators.emplace_back(op63, xnn_delete_operator);
1788
1789 #if XNN_PLATFORM_JIT
1790 xnn_finalize_code_memory(&code_cache.cache.code);
1791 #endif
1792
1793 status = xnn_setup_convolution2d_nchw_f32(
1794 op0,
1795 1 /* batch size */, 224 /* input height */, 224 /* input width */,
1796 v0.data() /* input */, v1.data() /* output */,
1797 threadpool /* threadpool */);
1798 if (status != xnn_status_success) {
1799 std::cerr << "failed to setup operation #0" << std::endl;
1800 return ExecutionPlan();
1801 }
1802
1803 status = xnn_setup_convolution2d_nchw_f32(
1804 op1,
1805 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1806 v1.data() /* input */, v2.data() /* output */,
1807 threadpool /* threadpool */);
1808 if (status != xnn_status_success) {
1809 std::cerr << "failed to setup operation #1" << std::endl;
1810 return ExecutionPlan();
1811 }
1812
1813 status = xnn_setup_convolution2d_nchw_f32(
1814 op2,
1815 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1816 v2.data() /* input */, v3.data() /* output */,
1817 threadpool /* threadpool */);
1818 if (status != xnn_status_success) {
1819 std::cerr << "failed to setup operation #2" << std::endl;
1820 return ExecutionPlan();
1821 }
1822
1823 status = xnn_setup_convolution2d_nchw_f32(
1824 op3,
1825 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1826 v3.data() /* input */, v4.data() /* output */,
1827 threadpool /* threadpool */);
1828 if (status != xnn_status_success) {
1829 std::cerr << "failed to setup operation #3" << std::endl;
1830 return ExecutionPlan();
1831 }
1832
1833 status = xnn_setup_convolution2d_nchw_f32(
1834 op4,
1835 1 /* batch size */, 112 /* input height */, 112 /* input width */,
1836 v4.data() /* input */, v5.data() /* output */,
1837 threadpool /* threadpool */);
1838 if (status != xnn_status_success) {
1839 std::cerr << "failed to setup operation #4" << std::endl;
1840 return ExecutionPlan();
1841 }
1842
1843 status = xnn_setup_convolution2d_nchw_f32(
1844 op5,
1845 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1846 v5.data() /* input */, v6.data() /* output */,
1847 threadpool /* threadpool */);
1848 if (status != xnn_status_success) {
1849 std::cerr << "failed to setup operation #5" << std::endl;
1850 return ExecutionPlan();
1851 }
1852
1853 status = xnn_setup_convolution2d_nchw_f32(
1854 op6,
1855 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1856 v6.data() /* input */, v7.data() /* output */,
1857 threadpool /* threadpool */);
1858 if (status != xnn_status_success) {
1859 std::cerr << "failed to setup operation #6" << std::endl;
1860 return ExecutionPlan();
1861 }
1862
1863 status = xnn_setup_convolution2d_nchw_f32(
1864 op7,
1865 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1866 v7.data() /* input */, v8.data() /* output */,
1867 threadpool /* threadpool */);
1868 if (status != xnn_status_success) {
1869 std::cerr << "failed to setup operation #7" << std::endl;
1870 return ExecutionPlan();
1871 }
1872
1873 status = xnn_setup_convolution2d_nchw_f32(
1874 op8,
1875 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1876 v8.data() /* input */, v9.data() /* output */,
1877 threadpool /* threadpool */);
1878 if (status != xnn_status_success) {
1879 std::cerr << "failed to setup operation #8" << std::endl;
1880 return ExecutionPlan();
1881 }
1882
1883 {
1884 const size_t a_shape[] = { 1, 24, 56, 56 };
1885 const size_t b_shape[] = { 1, 24, 56, 56 };
1886 status = xnn_setup_add_nd_f32(
1887 op9,
1888 4, a_shape, 4, b_shape,
1889 v9.data() /* a */, v6.data() /* b */, v10.data() /* output */,
1890 threadpool /* threadpool */);
1891 }
1892 if (status != xnn_status_success) {
1893 std::cerr << "failed to setup operation #9" << std::endl;
1894 return ExecutionPlan();
1895 }
1896
1897 status = xnn_setup_convolution2d_nchw_f32(
1898 op10,
1899 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1900 v10.data() /* input */, v11.data() /* output */,
1901 threadpool /* threadpool */);
1902 if (status != xnn_status_success) {
1903 std::cerr << "failed to setup operation #10" << std::endl;
1904 return ExecutionPlan();
1905 }
1906
1907 status = xnn_setup_convolution2d_nchw_f32(
1908 op11,
1909 1 /* batch size */, 56 /* input height */, 56 /* input width */,
1910 v11.data() /* input */, v12.data() /* output */,
1911 threadpool /* threadpool */);
1912 if (status != xnn_status_success) {
1913 std::cerr << "failed to setup operation #11" << std::endl;
1914 return ExecutionPlan();
1915 }
1916
1917 status = xnn_setup_convolution2d_nchw_f32(
1918 op12,
1919 1 /* batch size */, 28 /* input height */, 28 /* input width */,
1920 v12.data() /* input */, v13.data() /* output */,
1921 threadpool /* threadpool */);
1922 if (status != xnn_status_success) {
1923 std::cerr << "failed to setup operation #12" << std::endl;
1924 return ExecutionPlan();
1925 }
1926
1927 status = xnn_setup_convolution2d_nchw_f32(
1928 op13,
1929 1 /* batch size */, 28 /* input height */, 28 /* input width */,
1930 v13.data() /* input */, v14.data() /* output */,
1931 threadpool /* threadpool */);
1932 if (status != xnn_status_success) {
1933 std::cerr << "failed to setup operation #13" << std::endl;
1934 return ExecutionPlan();
1935 }
1936
1937 status = xnn_setup_convolution2d_nchw_f32(
1938 op14,
1939 1 /* batch size */, 28 /* input height */, 28 /* input width */,
1940 v14.data() /* input */, v15.data() /* output */,
1941 threadpool /* threadpool */);
1942 if (status != xnn_status_success) {
1943 std::cerr << "failed to setup operation #14" << std::endl;
1944 return ExecutionPlan();
1945 }
1946
1947 status = xnn_setup_convolution2d_nchw_f32(
1948 op15,
1949 1 /* batch size */, 28 /* input height */, 28 /* input width */,
1950 v15.data() /* input */, v16.data() /* output */,
1951 threadpool /* threadpool */);
1952 if (status != xnn_status_success) {
1953 std::cerr << "failed to setup operation #15" << std::endl;
1954 return ExecutionPlan();
1955 }
1956
1957 {
1958 const size_t a_shape[] = { 1, 32, 28, 28 };
1959 const size_t b_shape[] = { 1, 32, 28, 28 };
1960 status = xnn_setup_add_nd_f32(
1961 op16,
1962 4, a_shape, 4, b_shape,
1963 v16.data() /* a */, v13.data() /* b */, v17.data() /* output */,
1964 threadpool /* threadpool */);
1965 }
1966 if (status != xnn_status_success) {
1967 std::cerr << "failed to setup operation #16" << std::endl;
1968 return ExecutionPlan();
1969 }
1970
1971 status = xnn_setup_convolution2d_nchw_f32(
1972 op17,
1973 1 /* batch size */, 28 /* input height */, 28 /* input width */,
1974 v17.data() /* input */, v18.data() /* output */,
1975 threadpool /* threadpool */);
1976 if (status != xnn_status_success) {
1977 std::cerr << "failed to setup operation #17" << std::endl;
1978 return ExecutionPlan();
1979 }
1980
1981 status = xnn_setup_convolution2d_nchw_f32(
1982 op18,
1983 1 /* batch size */, 28 /* input height */, 28 /* input width */,
1984 v18.data() /* input */, v19.data() /* output */,
1985 threadpool /* threadpool */);
1986 if (status != xnn_status_success) {
1987 std::cerr << "failed to setup operation #18" << std::endl;
1988 return ExecutionPlan();
1989 }
1990
1991 status = xnn_setup_convolution2d_nchw_f32(
1992 op19,
1993 1 /* batch size */, 28 /* input height */, 28 /* input width */,
1994 v19.data() /* input */, v20.data() /* output */,
1995 threadpool /* threadpool */);
1996 if (status != xnn_status_success) {
1997 std::cerr << "failed to setup operation #19" << std::endl;
1998 return ExecutionPlan();
1999 }
2000
2001 {
2002 const size_t a_shape[] = { 1, 32, 28, 28 };
2003 const size_t b_shape[] = { 1, 32, 28, 28 };
2004 status = xnn_setup_add_nd_f32(
2005 op20,
2006 4, a_shape, 4, b_shape,
2007 v20.data() /* a */, v17.data() /* b */, v21.data() /* output */,
2008 threadpool /* threadpool */);
2009 }
2010 if (status != xnn_status_success) {
2011 std::cerr << "failed to setup operation #20" << std::endl;
2012 return ExecutionPlan();
2013 }
2014
2015 status = xnn_setup_convolution2d_nchw_f32(
2016 op21,
2017 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2018 v21.data() /* input */, v22.data() /* output */,
2019 threadpool /* threadpool */);
2020 if (status != xnn_status_success) {
2021 std::cerr << "failed to setup operation #21" << std::endl;
2022 return ExecutionPlan();
2023 }
2024
2025 status = xnn_setup_convolution2d_nchw_f32(
2026 op22,
2027 1 /* batch size */, 28 /* input height */, 28 /* input width */,
2028 v22.data() /* input */, v23.data() /* output */,
2029 threadpool /* threadpool */);
2030 if (status != xnn_status_success) {
2031 std::cerr << "failed to setup operation #22" << std::endl;
2032 return ExecutionPlan();
2033 }
2034
2035 status = xnn_setup_convolution2d_nchw_f32(
2036 op23,
2037 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2038 v23.data() /* input */, v24.data() /* output */,
2039 threadpool /* threadpool */);
2040 if (status != xnn_status_success) {
2041 std::cerr << "failed to setup operation #23" << std::endl;
2042 return ExecutionPlan();
2043 }
2044
2045 status = xnn_setup_convolution2d_nchw_f32(
2046 op24,
2047 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2048 v24.data() /* input */, v25.data() /* output */,
2049 threadpool /* threadpool */);
2050 if (status != xnn_status_success) {
2051 std::cerr << "failed to setup operation #24" << std::endl;
2052 return ExecutionPlan();
2053 }
2054
2055 status = xnn_setup_convolution2d_nchw_f32(
2056 op25,
2057 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2058 v25.data() /* input */, v26.data() /* output */,
2059 threadpool /* threadpool */);
2060 if (status != xnn_status_success) {
2061 std::cerr << "failed to setup operation #25" << std::endl;
2062 return ExecutionPlan();
2063 }
2064
2065 status = xnn_setup_convolution2d_nchw_f32(
2066 op26,
2067 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2068 v26.data() /* input */, v27.data() /* output */,
2069 threadpool /* threadpool */);
2070 if (status != xnn_status_success) {
2071 std::cerr << "failed to setup operation #26" << std::endl;
2072 return ExecutionPlan();
2073 }
2074
2075 {
2076 const size_t a_shape[] = { 1, 64, 14, 14 };
2077 const size_t b_shape[] = { 1, 64, 14, 14 };
2078 status = xnn_setup_add_nd_f32(
2079 op27,
2080 4, a_shape, 4, b_shape,
2081 v27.data() /* a */, v24.data() /* b */, v28.data() /* output */,
2082 threadpool /* threadpool */);
2083 }
2084 if (status != xnn_status_success) {
2085 std::cerr << "failed to setup operation #27" << std::endl;
2086 return ExecutionPlan();
2087 }
2088
2089 status = xnn_setup_convolution2d_nchw_f32(
2090 op28,
2091 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2092 v28.data() /* input */, v29.data() /* output */,
2093 threadpool /* threadpool */);
2094 if (status != xnn_status_success) {
2095 std::cerr << "failed to setup operation #28" << std::endl;
2096 return ExecutionPlan();
2097 }
2098
2099 status = xnn_setup_convolution2d_nchw_f32(
2100 op29,
2101 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2102 v29.data() /* input */, v30.data() /* output */,
2103 threadpool /* threadpool */);
2104 if (status != xnn_status_success) {
2105 std::cerr << "failed to setup operation #29" << std::endl;
2106 return ExecutionPlan();
2107 }
2108
2109 status = xnn_setup_convolution2d_nchw_f32(
2110 op30,
2111 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2112 v30.data() /* input */, v31.data() /* output */,
2113 threadpool /* threadpool */);
2114 if (status != xnn_status_success) {
2115 std::cerr << "failed to setup operation #30" << std::endl;
2116 return ExecutionPlan();
2117 }
2118
2119 {
2120 const size_t a_shape[] = { 1, 64, 14, 14 };
2121 const size_t b_shape[] = { 1, 64, 14, 14 };
2122 status = xnn_setup_add_nd_f32(
2123 op31,
2124 4, a_shape, 4, b_shape,
2125 v31.data() /* a */, v28.data() /* b */, v32.data() /* output */,
2126 threadpool /* threadpool */);
2127 }
2128 if (status != xnn_status_success) {
2129 std::cerr << "failed to setup operation #31" << std::endl;
2130 return ExecutionPlan();
2131 }
2132
2133 status = xnn_setup_convolution2d_nchw_f32(
2134 op32,
2135 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2136 v32.data() /* input */, v33.data() /* output */,
2137 threadpool /* threadpool */);
2138 if (status != xnn_status_success) {
2139 std::cerr << "failed to setup operation #32" << std::endl;
2140 return ExecutionPlan();
2141 }
2142
2143 status = xnn_setup_convolution2d_nchw_f32(
2144 op33,
2145 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2146 v33.data() /* input */, v34.data() /* output */,
2147 threadpool /* threadpool */);
2148 if (status != xnn_status_success) {
2149 std::cerr << "failed to setup operation #33" << std::endl;
2150 return ExecutionPlan();
2151 }
2152
2153 status = xnn_setup_convolution2d_nchw_f32(
2154 op34,
2155 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2156 v34.data() /* input */, v35.data() /* output */,
2157 threadpool /* threadpool */);
2158 if (status != xnn_status_success) {
2159 std::cerr << "failed to setup operation #34" << std::endl;
2160 return ExecutionPlan();
2161 }
2162
2163 {
2164 const size_t a_shape[] = { 1, 64, 14, 14 };
2165 const size_t b_shape[] = { 1, 64, 14, 14 };
2166 status = xnn_setup_add_nd_f32(
2167 op35,
2168 4, a_shape, 4, b_shape,
2169 v35.data() /* a */, v32.data() /* b */, v36.data() /* output */,
2170 threadpool /* threadpool */);
2171 }
2172 if (status != xnn_status_success) {
2173 std::cerr << "failed to setup operation #35" << std::endl;
2174 return ExecutionPlan();
2175 }
2176
2177 status = xnn_setup_convolution2d_nchw_f32(
2178 op36,
2179 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2180 v36.data() /* input */, v37.data() /* output */,
2181 threadpool /* threadpool */);
2182 if (status != xnn_status_success) {
2183 std::cerr << "failed to setup operation #36" << std::endl;
2184 return ExecutionPlan();
2185 }
2186
2187 status = xnn_setup_convolution2d_nchw_f32(
2188 op37,
2189 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2190 v37.data() /* input */, v38.data() /* output */,
2191 threadpool /* threadpool */);
2192 if (status != xnn_status_success) {
2193 std::cerr << "failed to setup operation #37" << std::endl;
2194 return ExecutionPlan();
2195 }
2196
2197 status = xnn_setup_convolution2d_nchw_f32(
2198 op38,
2199 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2200 v38.data() /* input */, v39.data() /* output */,
2201 threadpool /* threadpool */);
2202 if (status != xnn_status_success) {
2203 std::cerr << "failed to setup operation #38" << std::endl;
2204 return ExecutionPlan();
2205 }
2206
2207 status = xnn_setup_convolution2d_nchw_f32(
2208 op39,
2209 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2210 v39.data() /* input */, v40.data() /* output */,
2211 threadpool /* threadpool */);
2212 if (status != xnn_status_success) {
2213 std::cerr << "failed to setup operation #39" << std::endl;
2214 return ExecutionPlan();
2215 }
2216
2217 status = xnn_setup_convolution2d_nchw_f32(
2218 op40,
2219 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2220 v40.data() /* input */, v41.data() /* output */,
2221 threadpool /* threadpool */);
2222 if (status != xnn_status_success) {
2223 std::cerr << "failed to setup operation #40" << std::endl;
2224 return ExecutionPlan();
2225 }
2226
2227 status = xnn_setup_convolution2d_nchw_f32(
2228 op41,
2229 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2230 v41.data() /* input */, v42.data() /* output */,
2231 threadpool /* threadpool */);
2232 if (status != xnn_status_success) {
2233 std::cerr << "failed to setup operation #41" << std::endl;
2234 return ExecutionPlan();
2235 }
2236
2237 {
2238 const size_t a_shape[] = { 1, 96, 14, 14 };
2239 const size_t b_shape[] = { 1, 96, 14, 14 };
2240 status = xnn_setup_add_nd_f32(
2241 op42,
2242 4, a_shape, 4, b_shape,
2243 v42.data() /* a */, v39.data() /* b */, v43.data() /* output */,
2244 threadpool /* threadpool */);
2245 }
2246 if (status != xnn_status_success) {
2247 std::cerr << "failed to setup operation #42" << std::endl;
2248 return ExecutionPlan();
2249 }
2250
2251 status = xnn_setup_convolution2d_nchw_f32(
2252 op43,
2253 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2254 v43.data() /* input */, v44.data() /* output */,
2255 threadpool /* threadpool */);
2256 if (status != xnn_status_success) {
2257 std::cerr << "failed to setup operation #43" << std::endl;
2258 return ExecutionPlan();
2259 }
2260
2261 status = xnn_setup_convolution2d_nchw_f32(
2262 op44,
2263 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2264 v44.data() /* input */, v45.data() /* output */,
2265 threadpool /* threadpool */);
2266 if (status != xnn_status_success) {
2267 std::cerr << "failed to setup operation #44" << std::endl;
2268 return ExecutionPlan();
2269 }
2270
2271 status = xnn_setup_convolution2d_nchw_f32(
2272 op45,
2273 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2274 v45.data() /* input */, v46.data() /* output */,
2275 threadpool /* threadpool */);
2276 if (status != xnn_status_success) {
2277 std::cerr << "failed to setup operation #45" << std::endl;
2278 return ExecutionPlan();
2279 }
2280
2281 {
2282 const size_t a_shape[] = { 1, 96, 14, 14 };
2283 const size_t b_shape[] = { 1, 96, 14, 14 };
2284 status = xnn_setup_add_nd_f32(
2285 op46,
2286 4, a_shape, 4, b_shape,
2287 v46.data() /* a */, v43.data() /* b */, v47.data() /* output */,
2288 threadpool /* threadpool */);
2289 }
2290 if (status != xnn_status_success) {
2291 std::cerr << "failed to setup operation #46" << std::endl;
2292 return ExecutionPlan();
2293 }
2294
2295 status = xnn_setup_convolution2d_nchw_f32(
2296 op47,
2297 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2298 v47.data() /* input */, v48.data() /* output */,
2299 threadpool /* threadpool */);
2300 if (status != xnn_status_success) {
2301 std::cerr << "failed to setup operation #47" << std::endl;
2302 return ExecutionPlan();
2303 }
2304
2305 status = xnn_setup_convolution2d_nchw_f32(
2306 op48,
2307 1 /* batch size */, 14 /* input height */, 14 /* input width */,
2308 v48.data() /* input */, v49.data() /* output */,
2309 threadpool /* threadpool */);
2310 if (status != xnn_status_success) {
2311 std::cerr << "failed to setup operation #48" << std::endl;
2312 return ExecutionPlan();
2313 }
2314
2315 status = xnn_setup_convolution2d_nchw_f32(
2316 op49,
2317 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2318 v49.data() /* input */, v50.data() /* output */,
2319 threadpool /* threadpool */);
2320 if (status != xnn_status_success) {
2321 std::cerr << "failed to setup operation #49" << std::endl;
2322 return ExecutionPlan();
2323 }
2324
2325 status = xnn_setup_convolution2d_nchw_f32(
2326 op50,
2327 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2328 v50.data() /* input */, v51.data() /* output */,
2329 threadpool /* threadpool */);
2330 if (status != xnn_status_success) {
2331 std::cerr << "failed to setup operation #50" << std::endl;
2332 return ExecutionPlan();
2333 }
2334
2335 status = xnn_setup_convolution2d_nchw_f32(
2336 op51,
2337 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2338 v51.data() /* input */, v52.data() /* output */,
2339 threadpool /* threadpool */);
2340 if (status != xnn_status_success) {
2341 std::cerr << "failed to setup operation #51" << std::endl;
2342 return ExecutionPlan();
2343 }
2344
2345 status = xnn_setup_convolution2d_nchw_f32(
2346 op52,
2347 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2348 v52.data() /* input */, v53.data() /* output */,
2349 threadpool /* threadpool */);
2350 if (status != xnn_status_success) {
2351 std::cerr << "failed to setup operation #52" << std::endl;
2352 return ExecutionPlan();
2353 }
2354
2355 {
2356 const size_t a_shape[] = { 1, 160, 7, 7 };
2357 const size_t b_shape[] = { 1, 160, 7, 7 };
2358 status = xnn_setup_add_nd_f32(
2359 op53,
2360 4, a_shape, 4, b_shape,
2361 v53.data() /* a */, v50.data() /* b */, v54.data() /* output */,
2362 threadpool /* threadpool */);
2363 }
2364 if (status != xnn_status_success) {
2365 std::cerr << "failed to setup operation #53" << std::endl;
2366 return ExecutionPlan();
2367 }
2368
2369 status = xnn_setup_convolution2d_nchw_f32(
2370 op54,
2371 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2372 v54.data() /* input */, v55.data() /* output */,
2373 threadpool /* threadpool */);
2374 if (status != xnn_status_success) {
2375 std::cerr << "failed to setup operation #54" << std::endl;
2376 return ExecutionPlan();
2377 }
2378
2379 status = xnn_setup_convolution2d_nchw_f32(
2380 op55,
2381 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2382 v55.data() /* input */, v56.data() /* output */,
2383 threadpool /* threadpool */);
2384 if (status != xnn_status_success) {
2385 std::cerr << "failed to setup operation #55" << std::endl;
2386 return ExecutionPlan();
2387 }
2388
2389 status = xnn_setup_convolution2d_nchw_f32(
2390 op56,
2391 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2392 v56.data() /* input */, v57.data() /* output */,
2393 threadpool /* threadpool */);
2394 if (status != xnn_status_success) {
2395 std::cerr << "failed to setup operation #56" << std::endl;
2396 return ExecutionPlan();
2397 }
2398
2399 {
2400 const size_t a_shape[] = { 1, 160, 7, 7 };
2401 const size_t b_shape[] = { 1, 160, 7, 7 };
2402 status = xnn_setup_add_nd_f32(
2403 op57,
2404 4, a_shape, 4, b_shape,
2405 v57.data() /* a */, v54.data() /* b */, v58.data() /* output */,
2406 threadpool /* threadpool */);
2407 }
2408 if (status != xnn_status_success) {
2409 std::cerr << "failed to setup operation #57" << std::endl;
2410 return ExecutionPlan();
2411 }
2412
2413 status = xnn_setup_convolution2d_nchw_f32(
2414 op58,
2415 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2416 v58.data() /* input */, v59.data() /* output */,
2417 threadpool /* threadpool */);
2418 if (status != xnn_status_success) {
2419 std::cerr << "failed to setup operation #58" << std::endl;
2420 return ExecutionPlan();
2421 }
2422
2423 status = xnn_setup_convolution2d_nchw_f32(
2424 op59,
2425 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2426 v59.data() /* input */, v60.data() /* output */,
2427 threadpool /* threadpool */);
2428 if (status != xnn_status_success) {
2429 std::cerr << "failed to setup operation #59" << std::endl;
2430 return ExecutionPlan();
2431 }
2432
2433 status = xnn_setup_convolution2d_nchw_f32(
2434 op60,
2435 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2436 v60.data() /* input */, v61.data() /* output */,
2437 threadpool /* threadpool */);
2438 if (status != xnn_status_success) {
2439 std::cerr << "failed to setup operation #60" << std::endl;
2440 return ExecutionPlan();
2441 }
2442
2443 status = xnn_setup_convolution2d_nchw_f32(
2444 op61,
2445 1 /* batch size */, 7 /* input height */, 7 /* input width */,
2446 v61.data() /* input */, v62.data() /* output */,
2447 threadpool /* threadpool */);
2448 if (status != xnn_status_success) {
2449 std::cerr << "failed to setup operation #61" << std::endl;
2450 return ExecutionPlan();
2451 }
2452
2453 status = xnn_setup_global_average_pooling_ncw_f32(
2454 op62,
2455 1 /* batch size */, 49 /* width */,
2456 v62.data() /* input */, v63.data() /* output */,
2457 threadpool /* threadpool */);
2458 if (status != xnn_status_success) {
2459 std::cerr << "failed to setup operation #62" << std::endl;
2460 return ExecutionPlan();
2461 }
2462
2463 status = xnn_setup_convolution2d_nhwc_f32(
2464 op63,
2465 1 /* batch size */, 1 /* input height */, 1 /* input width */,
2466 v63.data() /* input */, v64.data() /* output */,
2467 threadpool /* threadpool */);
2468 if (status != xnn_status_success) {
2469 std::cerr << "failed to setup operation #63" << std::endl;
2470 return ExecutionPlan();
2471 }
2472
2473 #pragma clang diagnostic push
2474 #pragma clang diagnostic ignored "-Wpessimizing-move"
2475 return operators;
2476 #pragma clang diagnostic pop
2477 }
2478
2479 } // namespace models
2480