• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2020 Google LLC
2 //
3 // This source code is licensed under the BSD-style license found in the
4 // LICENSE file in the root directory of this source tree.
5 
6 #include <xnnpack.h>
7 
8 #include <array>
9 #include <algorithm>
10 #include <functional>
11 #include <iostream>
12 #include <limits>
13 #include <random>
14 
15 #include "models/models.h"
16 
17 namespace models {
18 
FP32SparseMobileNetV1(float sparsity,pthreadpool_t threadpool)19 ExecutionPlan FP32SparseMobileNetV1(float sparsity, pthreadpool_t threadpool) {
20   alignas(16) static std::array<float, 150528> v0;
21   alignas(16) static std::array<float, 401408> v1;
22   alignas(16) static std::array<float, 401408> v2;
23   alignas(16) static std::array<float, 802816> v3;
24   alignas(16) static std::array<float, 200704> v4;
25   alignas(16) static std::array<float, 401408> v5;
26   alignas(16) static std::array<float, 401408> v6;
27   alignas(16) static std::array<float, 401408> v7;
28   alignas(16) static std::array<float, 100352> v8;
29   alignas(16) static std::array<float, 200704> v9;
30   alignas(16) static std::array<float, 200704> v10;
31   alignas(16) static std::array<float, 200704> v11;
32   alignas(16) static std::array<float, 50176> v12;
33   alignas(16) static std::array<float, 100352> v13;
34   alignas(16) static std::array<float, 100352> v14;
35   alignas(16) static std::array<float, 100352> v15;
36   alignas(16) static std::array<float, 100352> v16;
37   alignas(16) static std::array<float, 100352> v17;
38   alignas(16) static std::array<float, 100352> v18;
39   alignas(16) static std::array<float, 100352> v19;
40   alignas(16) static std::array<float, 100352> v20;
41   alignas(16) static std::array<float, 100352> v21;
42   alignas(16) static std::array<float, 100352> v22;
43   alignas(16) static std::array<float, 100352> v23;
44   alignas(16) static std::array<float, 25088> v24;
45   alignas(16) static std::array<float, 50176> v25;
46   alignas(16) static std::array<float, 50176> v26;
47   alignas(16) static std::array<float, 50176> v27;
48   alignas(16) static std::array<float, 1024> v28;
49   alignas(16) static std::array<float, 1001> v29;
50   alignas(16) static std::array<float, 864> w30;
51   alignas(16) static std::array<float, 32> w31;
52   alignas(16) static std::array<float, 288> w32;
53   alignas(16) static std::array<float, 32> w33;
54   alignas(16) static std::array<float, 2048> w34;
55   alignas(16) static std::array<float, 64> w35;
56   alignas(16) static std::array<float, 576> w36;
57   alignas(16) static std::array<float, 64> w37;
58   alignas(16) static std::array<float, 8192> w38;
59   alignas(16) static std::array<float, 128> w39;
60   alignas(16) static std::array<float, 1152> w40;
61   alignas(16) static std::array<float, 128> w41;
62   alignas(16) static std::array<float, 16384> w42;
63   alignas(16) static std::array<float, 128> w43;
64   alignas(16) static std::array<float, 1152> w44;
65   alignas(16) static std::array<float, 128> w45;
66   alignas(16) static std::array<float, 32768> w46;
67   alignas(16) static std::array<float, 256> w47;
68   alignas(16) static std::array<float, 2304> w48;
69   alignas(16) static std::array<float, 256> w49;
70   alignas(16) static std::array<float, 65536> w50;
71   alignas(16) static std::array<float, 256> w51;
72   alignas(16) static std::array<float, 2304> w52;
73   alignas(16) static std::array<float, 256> w53;
74   alignas(16) static std::array<float, 131072> w54;
75   alignas(16) static std::array<float, 512> w55;
76   alignas(16) static std::array<float, 4608> w56;
77   alignas(16) static std::array<float, 512> w57;
78   alignas(16) static std::array<float, 262144> w58;
79   alignas(16) static std::array<float, 512> w59;
80   alignas(16) static std::array<float, 4608> w60;
81   alignas(16) static std::array<float, 512> w61;
82   alignas(16) static std::array<float, 262144> w62;
83   alignas(16) static std::array<float, 512> w63;
84   alignas(16) static std::array<float, 4608> w64;
85   alignas(16) static std::array<float, 512> w65;
86   alignas(16) static std::array<float, 262144> w66;
87   alignas(16) static std::array<float, 512> w67;
88   alignas(16) static std::array<float, 4608> w68;
89   alignas(16) static std::array<float, 512> w69;
90   alignas(16) static std::array<float, 262144> w70;
91   alignas(16) static std::array<float, 512> w71;
92   alignas(16) static std::array<float, 4608> w72;
93   alignas(16) static std::array<float, 512> w73;
94   alignas(16) static std::array<float, 262144> w74;
95   alignas(16) static std::array<float, 512> w75;
96   alignas(16) static std::array<float, 4608> w76;
97   alignas(16) static std::array<float, 512> w77;
98   alignas(16) static std::array<float, 524288> w78;
99   alignas(16) static std::array<float, 1024> w79;
100   alignas(16) static std::array<float, 9216> w80;
101   alignas(16) static std::array<float, 1024> w81;
102   alignas(16) static std::array<float, 1048576> w82;
103   alignas(16) static std::array<float, 1024> w83;
104   alignas(16) static std::array<float, 1025024> w84;
105   alignas(16) static std::array<float, 1001> w85;
106 
107   std::random_device random_device;
108   auto rng = std::mt19937(random_device());
109   auto f32rng = std::bind(std::uniform_real_distribution<float>(-1.0f, +1.0f), std::ref(rng));
110   std::generate(v0.begin(), v0.end(), std::ref(f32rng));
111   std::generate(v1.begin(), v1.end(), std::ref(f32rng));
112   std::generate(v2.begin(), v2.end(), std::ref(f32rng));
113   std::generate(v3.begin(), v3.end(), std::ref(f32rng));
114   std::generate(v4.begin(), v4.end(), std::ref(f32rng));
115   std::generate(v5.begin(), v5.end(), std::ref(f32rng));
116   std::generate(v6.begin(), v6.end(), std::ref(f32rng));
117   std::generate(v7.begin(), v7.end(), std::ref(f32rng));
118   std::generate(v8.begin(), v8.end(), std::ref(f32rng));
119   std::generate(v9.begin(), v9.end(), std::ref(f32rng));
120   std::generate(v10.begin(), v10.end(), std::ref(f32rng));
121   std::generate(v11.begin(), v11.end(), std::ref(f32rng));
122   std::generate(v12.begin(), v12.end(), std::ref(f32rng));
123   std::generate(v13.begin(), v13.end(), std::ref(f32rng));
124   std::generate(v14.begin(), v14.end(), std::ref(f32rng));
125   std::generate(v15.begin(), v15.end(), std::ref(f32rng));
126   std::generate(v16.begin(), v16.end(), std::ref(f32rng));
127   std::generate(v17.begin(), v17.end(), std::ref(f32rng));
128   std::generate(v18.begin(), v18.end(), std::ref(f32rng));
129   std::generate(v19.begin(), v19.end(), std::ref(f32rng));
130   std::generate(v20.begin(), v20.end(), std::ref(f32rng));
131   std::generate(v21.begin(), v21.end(), std::ref(f32rng));
132   std::generate(v22.begin(), v22.end(), std::ref(f32rng));
133   std::generate(v23.begin(), v23.end(), std::ref(f32rng));
134   std::generate(v24.begin(), v24.end(), std::ref(f32rng));
135   std::generate(v25.begin(), v25.end(), std::ref(f32rng));
136   std::generate(v26.begin(), v26.end(), std::ref(f32rng));
137   std::generate(v27.begin(), v27.end(), std::ref(f32rng));
138   std::generate(v28.begin(), v28.end(), std::ref(f32rng));
139   std::generate(v29.begin(), v29.end(), std::ref(f32rng));
140   std::generate(w30.begin(), w30.end(), std::ref(f32rng));
141   std::generate(w31.begin(), w31.end(), std::ref(f32rng));
142   std::generate(w32.begin(), w32.end(), std::ref(f32rng));
143   std::generate(w33.begin(), w33.end(), std::ref(f32rng));
144   std::fill(w34.begin(), w34.end(), 0.0f);
145   std::generate(w34.begin(), w34.end() - size_t(sparsity * w34.size()), std::ref(f32rng));
146   std::shuffle(w34.begin(), w34.end(), rng);
147   std::generate(w35.begin(), w35.end(), std::ref(f32rng));
148   std::generate(w36.begin(), w36.end(), std::ref(f32rng));
149   std::generate(w37.begin(), w37.end(), std::ref(f32rng));
150   std::fill(w38.begin(), w38.end(), 0.0f);
151   std::generate(w38.begin(), w38.end() - size_t(sparsity * w38.size()), std::ref(f32rng));
152   std::shuffle(w38.begin(), w38.end(), rng);
153   std::generate(w39.begin(), w39.end(), std::ref(f32rng));
154   std::generate(w40.begin(), w40.end(), std::ref(f32rng));
155   std::generate(w41.begin(), w41.end(), std::ref(f32rng));
156   std::fill(w42.begin(), w42.end(), 0.0f);
157   std::generate(w42.begin(), w42.end() - size_t(sparsity * w42.size()), std::ref(f32rng));
158   std::shuffle(w42.begin(), w42.end(), rng);
159   std::generate(w43.begin(), w43.end(), std::ref(f32rng));
160   std::generate(w44.begin(), w44.end(), std::ref(f32rng));
161   std::generate(w45.begin(), w45.end(), std::ref(f32rng));
162   std::fill(w46.begin(), w46.end(), 0.0f);
163   std::generate(w46.begin(), w46.end() - size_t(sparsity * w46.size()), std::ref(f32rng));
164   std::shuffle(w46.begin(), w46.end(), rng);
165   std::generate(w47.begin(), w47.end(), std::ref(f32rng));
166   std::generate(w48.begin(), w48.end(), std::ref(f32rng));
167   std::generate(w49.begin(), w49.end(), std::ref(f32rng));
168   std::fill(w50.begin(), w50.end(), 0.0f);
169   std::generate(w50.begin(), w50.end() - size_t(sparsity * w50.size()), std::ref(f32rng));
170   std::shuffle(w50.begin(), w50.end(), rng);
171   std::generate(w51.begin(), w51.end(), std::ref(f32rng));
172   std::generate(w52.begin(), w52.end(), std::ref(f32rng));
173   std::generate(w53.begin(), w53.end(), std::ref(f32rng));
174   std::fill(w54.begin(), w54.end(), 0.0f);
175   std::generate(w54.begin(), w54.end() - size_t(sparsity * w54.size()), std::ref(f32rng));
176   std::shuffle(w54.begin(), w54.end(), rng);
177   std::generate(w55.begin(), w55.end(), std::ref(f32rng));
178   std::generate(w56.begin(), w56.end(), std::ref(f32rng));
179   std::generate(w57.begin(), w57.end(), std::ref(f32rng));
180   std::fill(w58.begin(), w58.end(), 0.0f);
181   std::generate(w58.begin(), w58.end() - size_t(sparsity * w58.size()), std::ref(f32rng));
182   std::shuffle(w58.begin(), w58.end(), rng);
183   std::generate(w59.begin(), w59.end(), std::ref(f32rng));
184   std::generate(w60.begin(), w60.end(), std::ref(f32rng));
185   std::generate(w61.begin(), w61.end(), std::ref(f32rng));
186   std::fill(w62.begin(), w62.end(), 0.0f);
187   std::generate(w62.begin(), w62.end() - size_t(sparsity * w62.size()), std::ref(f32rng));
188   std::shuffle(w62.begin(), w62.end(), rng);
189   std::generate(w63.begin(), w63.end(), std::ref(f32rng));
190   std::generate(w64.begin(), w64.end(), std::ref(f32rng));
191   std::generate(w65.begin(), w65.end(), std::ref(f32rng));
192   std::fill(w66.begin(), w66.end(), 0.0f);
193   std::generate(w66.begin(), w66.end() - size_t(sparsity * w66.size()), std::ref(f32rng));
194   std::shuffle(w66.begin(), w66.end(), rng);
195   std::generate(w67.begin(), w67.end(), std::ref(f32rng));
196   std::generate(w68.begin(), w68.end(), std::ref(f32rng));
197   std::generate(w69.begin(), w69.end(), std::ref(f32rng));
198   std::fill(w70.begin(), w70.end(), 0.0f);
199   std::generate(w70.begin(), w70.end() - size_t(sparsity * w70.size()), std::ref(f32rng));
200   std::shuffle(w70.begin(), w70.end(), rng);
201   std::generate(w71.begin(), w71.end(), std::ref(f32rng));
202   std::generate(w72.begin(), w72.end(), std::ref(f32rng));
203   std::generate(w73.begin(), w73.end(), std::ref(f32rng));
204   std::fill(w74.begin(), w74.end(), 0.0f);
205   std::generate(w74.begin(), w74.end() - size_t(sparsity * w74.size()), std::ref(f32rng));
206   std::shuffle(w74.begin(), w74.end(), rng);
207   std::generate(w75.begin(), w75.end(), std::ref(f32rng));
208   std::generate(w76.begin(), w76.end(), std::ref(f32rng));
209   std::generate(w77.begin(), w77.end(), std::ref(f32rng));
210   std::fill(w78.begin(), w78.end(), 0.0f);
211   std::generate(w78.begin(), w78.end() - size_t(sparsity * w78.size()), std::ref(f32rng));
212   std::shuffle(w78.begin(), w78.end(), rng);
213   std::generate(w79.begin(), w79.end(), std::ref(f32rng));
214   std::generate(w80.begin(), w80.end(), std::ref(f32rng));
215   std::generate(w81.begin(), w81.end(), std::ref(f32rng));
216   std::fill(w82.begin(), w82.end(), 0.0f);
217   std::generate(w82.begin(), w82.end() - size_t(sparsity * w82.size()), std::ref(f32rng));
218   std::shuffle(w82.begin(), w82.end(), rng);
219   std::generate(w83.begin(), w83.end(), std::ref(f32rng));
220   std::generate(w84.begin(), w84.end(), std::ref(f32rng));
221   std::generate(w85.begin(), w85.end(), std::ref(f32rng));
222 
223   ExecutionPlan operators;
224   xnn_status status;
225 
226   xnn_operator_t op0 = nullptr;
227   status = xnn_create_convolution2d_nchw_f32(
228     1 /* top padding */, 1 /* right padding */,
229     1 /* bottom padding */, 1 /* left padding */,
230     3 /* kernel height */, 3 /* kernel width */,
231     2 /* subsampling height */, 2 /* subsampling width */,
232     1 /* dilation_height */, 1 /* dilation_width */,
233     1 /* groups */,
234     3 /* input channels per group */,
235     32 /* output_channels_per_group */,
236     3 /* input pixel stride */,
237     32 /* output pixel stride */,
238     w30.data(), w31.data(),
239     0.0f /* output min */, 6.0f /* output max */,
240     XNN_FLAG_INPUT_NHWC /* flags */,
241     &op0);
242   if (status != xnn_status_success) {
243     std::cerr << "failed to create operation #0" << std::endl;
244     return ExecutionPlan();
245   }
246   operators.emplace_back(op0, xnn_delete_operator);
247 
248   xnn_operator_t op1 = nullptr;
249   status = xnn_create_convolution2d_nchw_f32(
250     1 /* top padding */, 1 /* right padding */,
251     1 /* bottom padding */, 1 /* left padding */,
252     3 /* kernel height */, 3 /* kernel width */,
253     1 /* subsampling height */, 1 /* subsampling width */,
254     1 /* dilation_height */, 1 /* dilation_width */,
255     32 /* groups */,
256     1 /* input channels per group */,
257     1 /* output_channels_per_group */,
258     32 /* input pixel stride */,
259     32 /* output pixel stride */,
260     w32.data(), w33.data(),
261     0.0f /* output min */, 6.0f /* output max */,
262     0 /* flags */,
263     &op1);
264   if (status != xnn_status_success) {
265     std::cerr << "failed to create operation #1" << std::endl;
266     return ExecutionPlan();
267   }
268   operators.emplace_back(op1, xnn_delete_operator);
269 
270   xnn_operator_t op2 = nullptr;
271   status = xnn_create_convolution2d_nchw_f32(
272     0 /* top padding */, 0 /* right padding */,
273     0 /* bottom padding */, 0 /* left padding */,
274     1 /* kernel height */, 1 /* kernel width */,
275     1 /* subsampling height */, 1 /* subsampling width */,
276     1 /* dilation_height */, 1 /* dilation_width */,
277     1 /* groups */,
278     32 /* input channels per group */,
279     64 /* output_channels_per_group */,
280     32 /* input pixel stride */,
281     64 /* output pixel stride */,
282     w34.data(), w35.data(),
283     0.0f /* output min */, 6.0f /* output max */,
284     0 /* flags */,
285     &op2);
286   if (status != xnn_status_success) {
287     std::cerr << "failed to create operation #2" << std::endl;
288     return ExecutionPlan();
289   }
290   operators.emplace_back(op2, xnn_delete_operator);
291 
292   xnn_operator_t op3 = nullptr;
293   status = xnn_create_convolution2d_nchw_f32(
294     1 /* top padding */, 1 /* right padding */,
295     1 /* bottom padding */, 1 /* left padding */,
296     3 /* kernel height */, 3 /* kernel width */,
297     2 /* subsampling height */, 2 /* subsampling width */,
298     1 /* dilation_height */, 1 /* dilation_width */,
299     64 /* groups */,
300     1 /* input channels per group */,
301     1 /* output_channels_per_group */,
302     64 /* input pixel stride */,
303     64 /* output pixel stride */,
304     w36.data(), w37.data(),
305     0.0f /* output min */, 6.0f /* output max */,
306     0 /* flags */,
307     &op3);
308   if (status != xnn_status_success) {
309     std::cerr << "failed to create operation #3" << std::endl;
310     return ExecutionPlan();
311   }
312   operators.emplace_back(op3, xnn_delete_operator);
313 
314   xnn_operator_t op4 = nullptr;
315   status = xnn_create_convolution2d_nchw_f32(
316     0 /* top padding */, 0 /* right padding */,
317     0 /* bottom padding */, 0 /* left padding */,
318     1 /* kernel height */, 1 /* kernel width */,
319     1 /* subsampling height */, 1 /* subsampling width */,
320     1 /* dilation_height */, 1 /* dilation_width */,
321     1 /* groups */,
322     64 /* input channels per group */,
323     128 /* output_channels_per_group */,
324     64 /* input pixel stride */,
325     128 /* output pixel stride */,
326     w38.data(), w39.data(),
327     0.0f /* output min */, 6.0f /* output max */,
328     0 /* flags */,
329     &op4);
330   if (status != xnn_status_success) {
331     std::cerr << "failed to create operation #4" << std::endl;
332     return ExecutionPlan();
333   }
334   operators.emplace_back(op4, xnn_delete_operator);
335 
336   xnn_operator_t op5 = nullptr;
337   status = xnn_create_convolution2d_nchw_f32(
338     1 /* top padding */, 1 /* right padding */,
339     1 /* bottom padding */, 1 /* left padding */,
340     3 /* kernel height */, 3 /* kernel width */,
341     1 /* subsampling height */, 1 /* subsampling width */,
342     1 /* dilation_height */, 1 /* dilation_width */,
343     128 /* groups */,
344     1 /* input channels per group */,
345     1 /* output_channels_per_group */,
346     128 /* input pixel stride */,
347     128 /* output pixel stride */,
348     w40.data(), w41.data(),
349     0.0f /* output min */, 6.0f /* output max */,
350     0 /* flags */,
351     &op5);
352   if (status != xnn_status_success) {
353     std::cerr << "failed to create operation #5" << std::endl;
354     return ExecutionPlan();
355   }
356   operators.emplace_back(op5, xnn_delete_operator);
357 
358   xnn_operator_t op6 = nullptr;
359   status = xnn_create_convolution2d_nchw_f32(
360     0 /* top padding */, 0 /* right padding */,
361     0 /* bottom padding */, 0 /* left padding */,
362     1 /* kernel height */, 1 /* kernel width */,
363     1 /* subsampling height */, 1 /* subsampling width */,
364     1 /* dilation_height */, 1 /* dilation_width */,
365     1 /* groups */,
366     128 /* input channels per group */,
367     128 /* output_channels_per_group */,
368     128 /* input pixel stride */,
369     128 /* output pixel stride */,
370     w42.data(), w43.data(),
371     0.0f /* output min */, 6.0f /* output max */,
372     0 /* flags */,
373     &op6);
374   if (status != xnn_status_success) {
375     std::cerr << "failed to create operation #6" << std::endl;
376     return ExecutionPlan();
377   }
378   operators.emplace_back(op6, xnn_delete_operator);
379 
380   xnn_operator_t op7 = nullptr;
381   status = xnn_create_convolution2d_nchw_f32(
382     1 /* top padding */, 1 /* right padding */,
383     1 /* bottom padding */, 1 /* left padding */,
384     3 /* kernel height */, 3 /* kernel width */,
385     2 /* subsampling height */, 2 /* subsampling width */,
386     1 /* dilation_height */, 1 /* dilation_width */,
387     128 /* groups */,
388     1 /* input channels per group */,
389     1 /* output_channels_per_group */,
390     128 /* input pixel stride */,
391     128 /* output pixel stride */,
392     w44.data(), w45.data(),
393     0.0f /* output min */, 6.0f /* output max */,
394     0 /* flags */,
395     &op7);
396   if (status != xnn_status_success) {
397     std::cerr << "failed to create operation #7" << std::endl;
398     return ExecutionPlan();
399   }
400   operators.emplace_back(op7, xnn_delete_operator);
401 
402   xnn_operator_t op8 = nullptr;
403   status = xnn_create_convolution2d_nchw_f32(
404     0 /* top padding */, 0 /* right padding */,
405     0 /* bottom padding */, 0 /* left padding */,
406     1 /* kernel height */, 1 /* kernel width */,
407     1 /* subsampling height */, 1 /* subsampling width */,
408     1 /* dilation_height */, 1 /* dilation_width */,
409     1 /* groups */,
410     128 /* input channels per group */,
411     256 /* output_channels_per_group */,
412     128 /* input pixel stride */,
413     256 /* output pixel stride */,
414     w46.data(), w47.data(),
415     0.0f /* output min */, 6.0f /* output max */,
416     0 /* flags */,
417     &op8);
418   if (status != xnn_status_success) {
419     std::cerr << "failed to create operation #8" << std::endl;
420     return ExecutionPlan();
421   }
422   operators.emplace_back(op8, xnn_delete_operator);
423 
424   xnn_operator_t op9 = nullptr;
425   status = xnn_create_convolution2d_nchw_f32(
426     1 /* top padding */, 1 /* right padding */,
427     1 /* bottom padding */, 1 /* left padding */,
428     3 /* kernel height */, 3 /* kernel width */,
429     1 /* subsampling height */, 1 /* subsampling width */,
430     1 /* dilation_height */, 1 /* dilation_width */,
431     256 /* groups */,
432     1 /* input channels per group */,
433     1 /* output_channels_per_group */,
434     256 /* input pixel stride */,
435     256 /* output pixel stride */,
436     w48.data(), w49.data(),
437     0.0f /* output min */, 6.0f /* output max */,
438     0 /* flags */,
439     &op9);
440   if (status != xnn_status_success) {
441     std::cerr << "failed to create operation #9" << std::endl;
442     return ExecutionPlan();
443   }
444   operators.emplace_back(op9, xnn_delete_operator);
445 
446   xnn_operator_t op10 = nullptr;
447   status = xnn_create_convolution2d_nchw_f32(
448     0 /* top padding */, 0 /* right padding */,
449     0 /* bottom padding */, 0 /* left padding */,
450     1 /* kernel height */, 1 /* kernel width */,
451     1 /* subsampling height */, 1 /* subsampling width */,
452     1 /* dilation_height */, 1 /* dilation_width */,
453     1 /* groups */,
454     256 /* input channels per group */,
455     256 /* output_channels_per_group */,
456     256 /* input pixel stride */,
457     256 /* output pixel stride */,
458     w50.data(), w51.data(),
459     0.0f /* output min */, 6.0f /* output max */,
460     0 /* flags */,
461     &op10);
462   if (status != xnn_status_success) {
463     std::cerr << "failed to create operation #10" << std::endl;
464     return ExecutionPlan();
465   }
466   operators.emplace_back(op10, xnn_delete_operator);
467 
468   xnn_operator_t op11 = nullptr;
469   status = xnn_create_convolution2d_nchw_f32(
470     1 /* top padding */, 1 /* right padding */,
471     1 /* bottom padding */, 1 /* left padding */,
472     3 /* kernel height */, 3 /* kernel width */,
473     2 /* subsampling height */, 2 /* subsampling width */,
474     1 /* dilation_height */, 1 /* dilation_width */,
475     256 /* groups */,
476     1 /* input channels per group */,
477     1 /* output_channels_per_group */,
478     256 /* input pixel stride */,
479     256 /* output pixel stride */,
480     w52.data(), w53.data(),
481     0.0f /* output min */, 6.0f /* output max */,
482     0 /* flags */,
483     &op11);
484   if (status != xnn_status_success) {
485     std::cerr << "failed to create operation #11" << std::endl;
486     return ExecutionPlan();
487   }
488   operators.emplace_back(op11, xnn_delete_operator);
489 
490   xnn_operator_t op12 = nullptr;
491   status = xnn_create_convolution2d_nchw_f32(
492     0 /* top padding */, 0 /* right padding */,
493     0 /* bottom padding */, 0 /* left padding */,
494     1 /* kernel height */, 1 /* kernel width */,
495     1 /* subsampling height */, 1 /* subsampling width */,
496     1 /* dilation_height */, 1 /* dilation_width */,
497     1 /* groups */,
498     256 /* input channels per group */,
499     512 /* output_channels_per_group */,
500     256 /* input pixel stride */,
501     512 /* output pixel stride */,
502     w54.data(), w55.data(),
503     0.0f /* output min */, 6.0f /* output max */,
504     0 /* flags */,
505     &op12);
506   if (status != xnn_status_success) {
507     std::cerr << "failed to create operation #12" << std::endl;
508     return ExecutionPlan();
509   }
510   operators.emplace_back(op12, xnn_delete_operator);
511 
512   xnn_operator_t op13 = nullptr;
513   status = xnn_create_convolution2d_nchw_f32(
514     1 /* top padding */, 1 /* right padding */,
515     1 /* bottom padding */, 1 /* left padding */,
516     3 /* kernel height */, 3 /* kernel width */,
517     1 /* subsampling height */, 1 /* subsampling width */,
518     1 /* dilation_height */, 1 /* dilation_width */,
519     512 /* groups */,
520     1 /* input channels per group */,
521     1 /* output_channels_per_group */,
522     512 /* input pixel stride */,
523     512 /* output pixel stride */,
524     w56.data(), w57.data(),
525     0.0f /* output min */, 6.0f /* output max */,
526     0 /* flags */,
527     &op13);
528   if (status != xnn_status_success) {
529     std::cerr << "failed to create operation #13" << std::endl;
530     return ExecutionPlan();
531   }
532   operators.emplace_back(op13, xnn_delete_operator);
533 
534   xnn_operator_t op14 = nullptr;
535   status = xnn_create_convolution2d_nchw_f32(
536     0 /* top padding */, 0 /* right padding */,
537     0 /* bottom padding */, 0 /* left padding */,
538     1 /* kernel height */, 1 /* kernel width */,
539     1 /* subsampling height */, 1 /* subsampling width */,
540     1 /* dilation_height */, 1 /* dilation_width */,
541     1 /* groups */,
542     512 /* input channels per group */,
543     512 /* output_channels_per_group */,
544     512 /* input pixel stride */,
545     512 /* output pixel stride */,
546     w58.data(), w59.data(),
547     0.0f /* output min */, 6.0f /* output max */,
548     0 /* flags */,
549     &op14);
550   if (status != xnn_status_success) {
551     std::cerr << "failed to create operation #14" << std::endl;
552     return ExecutionPlan();
553   }
554   operators.emplace_back(op14, xnn_delete_operator);
555 
556   xnn_operator_t op15 = nullptr;
557   status = xnn_create_convolution2d_nchw_f32(
558     1 /* top padding */, 1 /* right padding */,
559     1 /* bottom padding */, 1 /* left padding */,
560     3 /* kernel height */, 3 /* kernel width */,
561     1 /* subsampling height */, 1 /* subsampling width */,
562     1 /* dilation_height */, 1 /* dilation_width */,
563     512 /* groups */,
564     1 /* input channels per group */,
565     1 /* output_channels_per_group */,
566     512 /* input pixel stride */,
567     512 /* output pixel stride */,
568     w60.data(), w61.data(),
569     0.0f /* output min */, 6.0f /* output max */,
570     0 /* flags */,
571     &op15);
572   if (status != xnn_status_success) {
573     std::cerr << "failed to create operation #15" << std::endl;
574     return ExecutionPlan();
575   }
576   operators.emplace_back(op15, xnn_delete_operator);
577 
578   xnn_operator_t op16 = nullptr;
579   status = xnn_create_convolution2d_nchw_f32(
580     0 /* top padding */, 0 /* right padding */,
581     0 /* bottom padding */, 0 /* left padding */,
582     1 /* kernel height */, 1 /* kernel width */,
583     1 /* subsampling height */, 1 /* subsampling width */,
584     1 /* dilation_height */, 1 /* dilation_width */,
585     1 /* groups */,
586     512 /* input channels per group */,
587     512 /* output_channels_per_group */,
588     512 /* input pixel stride */,
589     512 /* output pixel stride */,
590     w62.data(), w63.data(),
591     0.0f /* output min */, 6.0f /* output max */,
592     0 /* flags */,
593     &op16);
594   if (status != xnn_status_success) {
595     std::cerr << "failed to create operation #16" << std::endl;
596     return ExecutionPlan();
597   }
598   operators.emplace_back(op16, xnn_delete_operator);
599 
600   xnn_operator_t op17 = nullptr;
601   status = xnn_create_convolution2d_nchw_f32(
602     1 /* top padding */, 1 /* right padding */,
603     1 /* bottom padding */, 1 /* left padding */,
604     3 /* kernel height */, 3 /* kernel width */,
605     1 /* subsampling height */, 1 /* subsampling width */,
606     1 /* dilation_height */, 1 /* dilation_width */,
607     512 /* groups */,
608     1 /* input channels per group */,
609     1 /* output_channels_per_group */,
610     512 /* input pixel stride */,
611     512 /* output pixel stride */,
612     w64.data(), w65.data(),
613     0.0f /* output min */, 6.0f /* output max */,
614     0 /* flags */,
615     &op17);
616   if (status != xnn_status_success) {
617     std::cerr << "failed to create operation #17" << std::endl;
618     return ExecutionPlan();
619   }
620   operators.emplace_back(op17, xnn_delete_operator);
621 
622   xnn_operator_t op18 = nullptr;
623   status = xnn_create_convolution2d_nchw_f32(
624     0 /* top padding */, 0 /* right padding */,
625     0 /* bottom padding */, 0 /* left padding */,
626     1 /* kernel height */, 1 /* kernel width */,
627     1 /* subsampling height */, 1 /* subsampling width */,
628     1 /* dilation_height */, 1 /* dilation_width */,
629     1 /* groups */,
630     512 /* input channels per group */,
631     512 /* output_channels_per_group */,
632     512 /* input pixel stride */,
633     512 /* output pixel stride */,
634     w66.data(), w67.data(),
635     0.0f /* output min */, 6.0f /* output max */,
636     0 /* flags */,
637     &op18);
638   if (status != xnn_status_success) {
639     std::cerr << "failed to create operation #18" << std::endl;
640     return ExecutionPlan();
641   }
642   operators.emplace_back(op18, xnn_delete_operator);
643 
644   xnn_operator_t op19 = nullptr;
645   status = xnn_create_convolution2d_nchw_f32(
646     1 /* top padding */, 1 /* right padding */,
647     1 /* bottom padding */, 1 /* left padding */,
648     3 /* kernel height */, 3 /* kernel width */,
649     1 /* subsampling height */, 1 /* subsampling width */,
650     1 /* dilation_height */, 1 /* dilation_width */,
651     512 /* groups */,
652     1 /* input channels per group */,
653     1 /* output_channels_per_group */,
654     512 /* input pixel stride */,
655     512 /* output pixel stride */,
656     w68.data(), w69.data(),
657     0.0f /* output min */, 6.0f /* output max */,
658     0 /* flags */,
659     &op19);
660   if (status != xnn_status_success) {
661     std::cerr << "failed to create operation #19" << std::endl;
662     return ExecutionPlan();
663   }
664   operators.emplace_back(op19, xnn_delete_operator);
665 
666   xnn_operator_t op20 = 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     512 /* input channels per group */,
675     512 /* output_channels_per_group */,
676     512 /* input pixel stride */,
677     512 /* output pixel stride */,
678     w70.data(), w71.data(),
679     0.0f /* output min */, 6.0f /* output max */,
680     0 /* flags */,
681     &op20);
682   if (status != xnn_status_success) {
683     std::cerr << "failed to create operation #20" << std::endl;
684     return ExecutionPlan();
685   }
686   operators.emplace_back(op20, xnn_delete_operator);
687 
688   xnn_operator_t op21 = nullptr;
689   status = xnn_create_convolution2d_nchw_f32(
690     1 /* top padding */, 1 /* right padding */,
691     1 /* bottom padding */, 1 /* left padding */,
692     3 /* kernel height */, 3 /* kernel width */,
693     1 /* subsampling height */, 1 /* subsampling width */,
694     1 /* dilation_height */, 1 /* dilation_width */,
695     512 /* groups */,
696     1 /* input channels per group */,
697     1 /* output_channels_per_group */,
698     512 /* input pixel stride */,
699     512 /* output pixel stride */,
700     w72.data(), w73.data(),
701     0.0f /* output min */, 6.0f /* output max */,
702     0 /* flags */,
703     &op21);
704   if (status != xnn_status_success) {
705     std::cerr << "failed to create operation #21" << std::endl;
706     return ExecutionPlan();
707   }
708   operators.emplace_back(op21, xnn_delete_operator);
709 
710   xnn_operator_t op22 = nullptr;
711   status = xnn_create_convolution2d_nchw_f32(
712     0 /* top padding */, 0 /* right padding */,
713     0 /* bottom padding */, 0 /* left padding */,
714     1 /* kernel height */, 1 /* kernel width */,
715     1 /* subsampling height */, 1 /* subsampling width */,
716     1 /* dilation_height */, 1 /* dilation_width */,
717     1 /* groups */,
718     512 /* input channels per group */,
719     512 /* output_channels_per_group */,
720     512 /* input pixel stride */,
721     512 /* output pixel stride */,
722     w74.data(), w75.data(),
723     0.0f /* output min */, 6.0f /* output max */,
724     0 /* flags */,
725     &op22);
726   if (status != xnn_status_success) {
727     std::cerr << "failed to create operation #22" << std::endl;
728     return ExecutionPlan();
729   }
730   operators.emplace_back(op22, xnn_delete_operator);
731 
732   xnn_operator_t op23 = nullptr;
733   status = xnn_create_convolution2d_nchw_f32(
734     1 /* top padding */, 1 /* right padding */,
735     1 /* bottom padding */, 1 /* left padding */,
736     3 /* kernel height */, 3 /* kernel width */,
737     2 /* subsampling height */, 2 /* subsampling width */,
738     1 /* dilation_height */, 1 /* dilation_width */,
739     512 /* groups */,
740     1 /* input channels per group */,
741     1 /* output_channels_per_group */,
742     512 /* input pixel stride */,
743     512 /* output pixel stride */,
744     w76.data(), w77.data(),
745     0.0f /* output min */, 6.0f /* output max */,
746     0 /* flags */,
747     &op23);
748   if (status != xnn_status_success) {
749     std::cerr << "failed to create operation #23" << std::endl;
750     return ExecutionPlan();
751   }
752   operators.emplace_back(op23, xnn_delete_operator);
753 
754   xnn_operator_t op24 = nullptr;
755   status = xnn_create_convolution2d_nchw_f32(
756     0 /* top padding */, 0 /* right padding */,
757     0 /* bottom padding */, 0 /* left padding */,
758     1 /* kernel height */, 1 /* kernel width */,
759     1 /* subsampling height */, 1 /* subsampling width */,
760     1 /* dilation_height */, 1 /* dilation_width */,
761     1 /* groups */,
762     512 /* input channels per group */,
763     1024 /* output_channels_per_group */,
764     512 /* input pixel stride */,
765     1024 /* output pixel stride */,
766     w78.data(), w79.data(),
767     0.0f /* output min */, 6.0f /* output max */,
768     0 /* flags */,
769     &op24);
770   if (status != xnn_status_success) {
771     std::cerr << "failed to create operation #24" << std::endl;
772     return ExecutionPlan();
773   }
774   operators.emplace_back(op24, xnn_delete_operator);
775 
776   xnn_operator_t op25 = nullptr;
777   status = xnn_create_convolution2d_nchw_f32(
778     1 /* top padding */, 1 /* right padding */,
779     1 /* bottom padding */, 1 /* left padding */,
780     3 /* kernel height */, 3 /* kernel width */,
781     1 /* subsampling height */, 1 /* subsampling width */,
782     1 /* dilation_height */, 1 /* dilation_width */,
783     1024 /* groups */,
784     1 /* input channels per group */,
785     1 /* output_channels_per_group */,
786     1024 /* input pixel stride */,
787     1024 /* output pixel stride */,
788     w80.data(), w81.data(),
789     0.0f /* output min */, 6.0f /* output max */,
790     0 /* flags */,
791     &op25);
792   if (status != xnn_status_success) {
793     std::cerr << "failed to create operation #25" << std::endl;
794     return ExecutionPlan();
795   }
796   operators.emplace_back(op25, xnn_delete_operator);
797 
798   xnn_operator_t op26 = nullptr;
799   status = xnn_create_convolution2d_nchw_f32(
800     0 /* top padding */, 0 /* right padding */,
801     0 /* bottom padding */, 0 /* left padding */,
802     1 /* kernel height */, 1 /* kernel width */,
803     1 /* subsampling height */, 1 /* subsampling width */,
804     1 /* dilation_height */, 1 /* dilation_width */,
805     1 /* groups */,
806     1024 /* input channels per group */,
807     1024 /* output_channels_per_group */,
808     1024 /* input pixel stride */,
809     1024 /* output pixel stride */,
810     w82.data(), w83.data(),
811     0.0f /* output min */, 6.0f /* output max */,
812     0 /* flags */,
813     &op26);
814   if (status != xnn_status_success) {
815     std::cerr << "failed to create operation #26" << std::endl;
816     return ExecutionPlan();
817   }
818   operators.emplace_back(op26, xnn_delete_operator);
819 
820   xnn_operator_t op27 = nullptr;
821   status = xnn_create_global_average_pooling_ncw_f32(
822     1024 /* channels */,
823     -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(),
824     0 /* flags */,
825     &op27);
826   if (status != xnn_status_success) {
827     std::cerr << "failed to create operation #27" << std::endl;
828     return ExecutionPlan();
829   }
830   operators.emplace_back(op27, xnn_delete_operator);
831 
832   xnn_operator_t op28 = nullptr;
833   status = xnn_create_convolution2d_nhwc_f32(
834     0 /* top padding */, 0 /* right padding */,
835     0 /* bottom padding */, 0 /* left padding */,
836     1 /* kernel height */, 1 /* kernel width */,
837     1 /* subsampling height */, 1 /* subsampling width */,
838     1 /* dilation_height */, 1 /* dilation_width */,
839     1 /* groups */,
840     1024 /* input channels per group */,
841     1001 /* output_channels_per_group */,
842     1024 /* input pixel stride */,
843     1001 /* output pixel stride */,
844     w84.data(), w85.data(),
845     -std::numeric_limits<float>::infinity() /* output min */, std::numeric_limits<float>::infinity() /* output max */,
846     0 /* flags */,
847     &op28);
848   if (status != xnn_status_success) {
849     std::cerr << "failed to create operation #28" << std::endl;
850     return ExecutionPlan();
851   }
852   operators.emplace_back(op28, xnn_delete_operator);
853 
854 
855 
856   status = xnn_setup_convolution2d_nchw_f32(
857     op0,
858     1 /* batch size */, 224 /* input height */, 224 /* input width */,
859     v0.data() /* input */, v1.data() /* output */,
860     threadpool /* threadpool */);
861   if (status != xnn_status_success) {
862     std::cerr << "failed to setup operation #0" << std::endl;
863     return ExecutionPlan();
864   }
865 
866   status = xnn_setup_convolution2d_nchw_f32(
867     op1,
868     1 /* batch size */, 112 /* input height */, 112 /* input width */,
869     v1.data() /* input */, v2.data() /* output */,
870     threadpool /* threadpool */);
871   if (status != xnn_status_success) {
872     std::cerr << "failed to setup operation #1" << std::endl;
873     return ExecutionPlan();
874   }
875 
876   status = xnn_setup_convolution2d_nchw_f32(
877     op2,
878     1 /* batch size */, 112 /* input height */, 112 /* input width */,
879     v2.data() /* input */, v3.data() /* output */,
880     threadpool /* threadpool */);
881   if (status != xnn_status_success) {
882     std::cerr << "failed to setup operation #2" << std::endl;
883     return ExecutionPlan();
884   }
885 
886   status = xnn_setup_convolution2d_nchw_f32(
887     op3,
888     1 /* batch size */, 112 /* input height */, 112 /* input width */,
889     v3.data() /* input */, v4.data() /* output */,
890     threadpool /* threadpool */);
891   if (status != xnn_status_success) {
892     std::cerr << "failed to setup operation #3" << std::endl;
893     return ExecutionPlan();
894   }
895 
896   status = xnn_setup_convolution2d_nchw_f32(
897     op4,
898     1 /* batch size */, 56 /* input height */, 56 /* input width */,
899     v4.data() /* input */, v5.data() /* output */,
900     threadpool /* threadpool */);
901   if (status != xnn_status_success) {
902     std::cerr << "failed to setup operation #4" << std::endl;
903     return ExecutionPlan();
904   }
905 
906   status = xnn_setup_convolution2d_nchw_f32(
907     op5,
908     1 /* batch size */, 56 /* input height */, 56 /* input width */,
909     v5.data() /* input */, v6.data() /* output */,
910     threadpool /* threadpool */);
911   if (status != xnn_status_success) {
912     std::cerr << "failed to setup operation #5" << std::endl;
913     return ExecutionPlan();
914   }
915 
916   status = xnn_setup_convolution2d_nchw_f32(
917     op6,
918     1 /* batch size */, 56 /* input height */, 56 /* input width */,
919     v6.data() /* input */, v7.data() /* output */,
920     threadpool /* threadpool */);
921   if (status != xnn_status_success) {
922     std::cerr << "failed to setup operation #6" << std::endl;
923     return ExecutionPlan();
924   }
925 
926   status = xnn_setup_convolution2d_nchw_f32(
927     op7,
928     1 /* batch size */, 56 /* input height */, 56 /* input width */,
929     v7.data() /* input */, v8.data() /* output */,
930     threadpool /* threadpool */);
931   if (status != xnn_status_success) {
932     std::cerr << "failed to setup operation #7" << std::endl;
933     return ExecutionPlan();
934   }
935 
936   status = xnn_setup_convolution2d_nchw_f32(
937     op8,
938     1 /* batch size */, 28 /* input height */, 28 /* input width */,
939     v8.data() /* input */, v9.data() /* output */,
940     threadpool /* threadpool */);
941   if (status != xnn_status_success) {
942     std::cerr << "failed to setup operation #8" << std::endl;
943     return ExecutionPlan();
944   }
945 
946   status = xnn_setup_convolution2d_nchw_f32(
947     op9,
948     1 /* batch size */, 28 /* input height */, 28 /* input width */,
949     v9.data() /* input */, v10.data() /* output */,
950     threadpool /* threadpool */);
951   if (status != xnn_status_success) {
952     std::cerr << "failed to setup operation #9" << std::endl;
953     return ExecutionPlan();
954   }
955 
956   status = xnn_setup_convolution2d_nchw_f32(
957     op10,
958     1 /* batch size */, 28 /* input height */, 28 /* input width */,
959     v10.data() /* input */, v11.data() /* output */,
960     threadpool /* threadpool */);
961   if (status != xnn_status_success) {
962     std::cerr << "failed to setup operation #10" << std::endl;
963     return ExecutionPlan();
964   }
965 
966   status = xnn_setup_convolution2d_nchw_f32(
967     op11,
968     1 /* batch size */, 28 /* input height */, 28 /* input width */,
969     v11.data() /* input */, v12.data() /* output */,
970     threadpool /* threadpool */);
971   if (status != xnn_status_success) {
972     std::cerr << "failed to setup operation #11" << std::endl;
973     return ExecutionPlan();
974   }
975 
976   status = xnn_setup_convolution2d_nchw_f32(
977     op12,
978     1 /* batch size */, 14 /* input height */, 14 /* input width */,
979     v12.data() /* input */, v13.data() /* output */,
980     threadpool /* threadpool */);
981   if (status != xnn_status_success) {
982     std::cerr << "failed to setup operation #12" << std::endl;
983     return ExecutionPlan();
984   }
985 
986   status = xnn_setup_convolution2d_nchw_f32(
987     op13,
988     1 /* batch size */, 14 /* input height */, 14 /* input width */,
989     v13.data() /* input */, v14.data() /* output */,
990     threadpool /* threadpool */);
991   if (status != xnn_status_success) {
992     std::cerr << "failed to setup operation #13" << std::endl;
993     return ExecutionPlan();
994   }
995 
996   status = xnn_setup_convolution2d_nchw_f32(
997     op14,
998     1 /* batch size */, 14 /* input height */, 14 /* input width */,
999     v14.data() /* input */, v15.data() /* output */,
1000     threadpool /* threadpool */);
1001   if (status != xnn_status_success) {
1002     std::cerr << "failed to setup operation #14" << std::endl;
1003     return ExecutionPlan();
1004   }
1005 
1006   status = xnn_setup_convolution2d_nchw_f32(
1007     op15,
1008     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1009     v15.data() /* input */, v16.data() /* output */,
1010     threadpool /* threadpool */);
1011   if (status != xnn_status_success) {
1012     std::cerr << "failed to setup operation #15" << std::endl;
1013     return ExecutionPlan();
1014   }
1015 
1016   status = xnn_setup_convolution2d_nchw_f32(
1017     op16,
1018     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1019     v16.data() /* input */, v17.data() /* output */,
1020     threadpool /* threadpool */);
1021   if (status != xnn_status_success) {
1022     std::cerr << "failed to setup operation #16" << std::endl;
1023     return ExecutionPlan();
1024   }
1025 
1026   status = xnn_setup_convolution2d_nchw_f32(
1027     op17,
1028     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1029     v17.data() /* input */, v18.data() /* output */,
1030     threadpool /* threadpool */);
1031   if (status != xnn_status_success) {
1032     std::cerr << "failed to setup operation #17" << std::endl;
1033     return ExecutionPlan();
1034   }
1035 
1036   status = xnn_setup_convolution2d_nchw_f32(
1037     op18,
1038     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1039     v18.data() /* input */, v19.data() /* output */,
1040     threadpool /* threadpool */);
1041   if (status != xnn_status_success) {
1042     std::cerr << "failed to setup operation #18" << std::endl;
1043     return ExecutionPlan();
1044   }
1045 
1046   status = xnn_setup_convolution2d_nchw_f32(
1047     op19,
1048     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1049     v19.data() /* input */, v20.data() /* output */,
1050     threadpool /* threadpool */);
1051   if (status != xnn_status_success) {
1052     std::cerr << "failed to setup operation #19" << std::endl;
1053     return ExecutionPlan();
1054   }
1055 
1056   status = xnn_setup_convolution2d_nchw_f32(
1057     op20,
1058     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1059     v20.data() /* input */, v21.data() /* output */,
1060     threadpool /* threadpool */);
1061   if (status != xnn_status_success) {
1062     std::cerr << "failed to setup operation #20" << std::endl;
1063     return ExecutionPlan();
1064   }
1065 
1066   status = xnn_setup_convolution2d_nchw_f32(
1067     op21,
1068     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1069     v21.data() /* input */, v22.data() /* output */,
1070     threadpool /* threadpool */);
1071   if (status != xnn_status_success) {
1072     std::cerr << "failed to setup operation #21" << std::endl;
1073     return ExecutionPlan();
1074   }
1075 
1076   status = xnn_setup_convolution2d_nchw_f32(
1077     op22,
1078     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1079     v22.data() /* input */, v23.data() /* output */,
1080     threadpool /* threadpool */);
1081   if (status != xnn_status_success) {
1082     std::cerr << "failed to setup operation #22" << std::endl;
1083     return ExecutionPlan();
1084   }
1085 
1086   status = xnn_setup_convolution2d_nchw_f32(
1087     op23,
1088     1 /* batch size */, 14 /* input height */, 14 /* input width */,
1089     v23.data() /* input */, v24.data() /* output */,
1090     threadpool /* threadpool */);
1091   if (status != xnn_status_success) {
1092     std::cerr << "failed to setup operation #23" << std::endl;
1093     return ExecutionPlan();
1094   }
1095 
1096   status = xnn_setup_convolution2d_nchw_f32(
1097     op24,
1098     1 /* batch size */, 7 /* input height */, 7 /* input width */,
1099     v24.data() /* input */, v25.data() /* output */,
1100     threadpool /* threadpool */);
1101   if (status != xnn_status_success) {
1102     std::cerr << "failed to setup operation #24" << std::endl;
1103     return ExecutionPlan();
1104   }
1105 
1106   status = xnn_setup_convolution2d_nchw_f32(
1107     op25,
1108     1 /* batch size */, 7 /* input height */, 7 /* input width */,
1109     v25.data() /* input */, v26.data() /* output */,
1110     threadpool /* threadpool */);
1111   if (status != xnn_status_success) {
1112     std::cerr << "failed to setup operation #25" << std::endl;
1113     return ExecutionPlan();
1114   }
1115 
1116   status = xnn_setup_convolution2d_nchw_f32(
1117     op26,
1118     1 /* batch size */, 7 /* input height */, 7 /* input width */,
1119     v26.data() /* input */, v27.data() /* output */,
1120     threadpool /* threadpool */);
1121   if (status != xnn_status_success) {
1122     std::cerr << "failed to setup operation #26" << std::endl;
1123     return ExecutionPlan();
1124   }
1125 
1126   status = xnn_setup_global_average_pooling_ncw_f32(
1127     op27,
1128     1 /* batch size */, 49 /* width */,
1129     v27.data() /* input */, v28.data() /* output */,
1130     threadpool /* threadpool */);
1131   if (status != xnn_status_success) {
1132     std::cerr << "failed to setup operation #27" << std::endl;
1133     return ExecutionPlan();
1134   }
1135 
1136   status = xnn_setup_convolution2d_nhwc_f32(
1137     op28,
1138     1 /* batch size */, 1 /* input height */, 1 /* input width */,
1139     v28.data() /* input */, v29.data() /* output */,
1140     threadpool /* threadpool */);
1141   if (status != xnn_status_success) {
1142     std::cerr << "failed to setup operation #28" << std::endl;
1143     return ExecutionPlan();
1144   }
1145 
1146   #pragma clang diagnostic push
1147   #pragma clang diagnostic ignored "-Wpessimizing-move"
1148   return operators;
1149   #pragma clang diagnostic pop
1150 }
1151 
1152 }  // namespace models
1153