asgn
 
Loading...
Searching...
No Matches
dcnncombined.hpp
1#ifndef dcnncombined_hpp_
2#define dcnncombined_hpp_
3
4#include "dcnnelements.hpp"
5#include "dcnnbinfile.hpp"
6
8namespace dcnnsol {
9 template< typename SP, is_policy PP>
10 struct first_normalize_layer;
11
12 template< typename SPI, typename SPO, typename KSP, is_policy PP>
13 struct nonstrided_conv_layer;
14
15 template< typename SPI, typename SPO, typename KSP, is_policy PP>
16 struct strided_conv_layer;
17
18 template< typename SP, is_policy PP>
19 struct image_normalize_layer;
20
21 template< typename SP, is_policy PP>
22 struct image_multiply_layer;
23
24 template< typename SP, is_policy PP>
25 struct image_shift_layer;
26
27 template< typename SP, is_policy PP>
28 struct image_relu_layer;
29
30 template< typename SPI, typename SPO, is_policy PP>
31 struct image_maxpool_layer;
32
33 template< typename SPI, typename CSPO, is_policy PP>
34 struct final_maxpool_layer;
35
36 template< typename CSPI, typename CSPO, is_policy PP>
37 struct feature_conv_layer;
38
39 template< typename CSP, is_policy PP>
40 struct feature_shift_layer;
41
42 template< typename CSP, is_policy PP>
43 struct loss_layer;
44}
46
47namespace dcnnasgn {
48
52
56 inline constexpr std::size_t LABELS = 1000;
57
61 struct xxxl_image_policy : image_size_policy< 224, 224> {};
65 struct xxl_image_policy : image_size_policy< 112, 112> {};
69 struct xl_image_policy : image_size_policy< 56, 56> {};
73 struct l_image_policy : image_size_policy< 28, 28> {};
77 struct m_image_policy : image_size_policy< 14, 14> {};
82
115
120
123
127
128 using idp = input_data_policy< xxxl_image_policy, rgb_channel_policy>;
129
130 struct first_data_policy : image_data_size_policy< xxxl_image_policy, rgb_channel_policy> {};
131 struct xxl_e_data_policy : image_data_size_policy< xxl_image_policy, e_channel_policy> {};
132 struct xl_f_data_policy : image_data_size_policy< xl_image_policy, f_channel_policy> {};
133 struct l_f_data_policy : image_data_size_policy< l_image_policy, f_channel_policy> {};
134 struct m_f_data_policy : image_data_size_policy< m_image_policy, f_channel_policy> {};
135 struct m_g_data_policy : image_data_size_policy< m_image_policy, g_channel_policy> {};
136 struct m_h_data_policy : image_data_size_policy< m_image_policy, h_channel_policy> {};
137 struct s_h_data_policy : image_data_size_policy< s_image_policy, h_channel_policy> {};
138 struct s_j_data_policy : image_data_size_policy< s_image_policy, j_channel_policy> {};
139 struct s_g_data_policy : image_data_size_policy< s_image_policy, g_channel_policy> {};
140
142
146
154 template< is_policy PP>
156 {
157 using layer_input_n = dcnnsol::first_normalize_layer< first_data_policy, PP>;
158 using layer_00 = dcnnsol::complete_cnn_layer< first_data_policy, xxl_e_data_policy, standard_kernel_policy, PP>;
159 using layer_04 = dcnnsol::complete_cnn_layer< xxl_e_data_policy, xl_f_data_policy, standard_kernel_policy, PP>;
160 using layer_08 = dcnnsol::complete_cnn_layer< xl_f_data_policy, xl_f_data_policy, standard_kernel_policy, PP>;
161 using layer_12 = dcnnsol::complete_cnn_layer< xl_f_data_policy, l_f_data_policy, standard_kernel_policy, PP>;
162 using layer_16 = dcnnsol::complete_cnn_layer< l_f_data_policy, l_f_data_policy, standard_kernel_policy, PP>;
163 using layer_20 = dcnnsol::complete_cnn_layer< l_f_data_policy, l_f_data_policy, standard_kernel_policy, PP>;
164 using layer_24_p = dcnnsol::image_maxpool_layer< l_f_data_policy, m_f_data_policy, PP>;
165 using layer_26 = dcnnsol::complete_cnn_layer< m_f_data_policy, m_g_data_policy, standard_kernel_policy, PP>;
166 using layer_30 = dcnnsol::complete_cnn_layer< m_g_data_policy, m_g_data_policy, standard_kernel_policy, PP>;
167 using layer_34 = dcnnsol::complete_cnn_layer< m_g_data_policy, m_g_data_policy, standard_kernel_policy, PP>;
168 using layer_38 = dcnnsol::complete_cnn_layer< m_g_data_policy, m_h_data_policy, standard_kernel_policy, PP>;
169 using layer_42_p = dcnnsol::image_maxpool_layer< m_h_data_policy, s_h_data_policy, PP>;
170 using layer_44 = dcnnsol::complete_cnn_layer< s_h_data_policy, s_j_data_policy, no_kernel_policy, PP>;
171 using layer_48 = dcnnsol::complete_cnn_layer< s_j_data_policy, s_g_data_policy, no_kernel_policy, PP>;
172 using layer_52 = dcnnsol::complete_cnn_layer< s_g_data_policy, s_g_data_policy, standard_kernel_policy, PP>;
173 using layer_final_p = dcnnsol::final_maxpool_layer< s_g_data_policy, g_channel_policy, PP>;
174 using layer_class_c = dcnnsol::feature_conv_layer< g_channel_policy, labels_channel_policy, PP>;
175 using layer_class_b = dcnnsol::feature_shift_layer< labels_channel_policy, PP>;
176 using loss = dcnnsol::loss_layer<labels_channel_policy, PP>;
177 };
178
183 template< is_policy PP>
185 public:
186 using policy = combined_policy< PP>;
187
188 using model_00 = typename policy::layer_00::model;
189 using model_04 = typename policy::layer_04::model;
190 using model_08 = typename policy::layer_08::model;
191 using model_12 = typename policy::layer_12::model;
192 using model_16 = typename policy::layer_16::model;
193 using model_20 = typename policy::layer_20::model;
194 using model_26 = typename policy::layer_26::model;
195 using model_30 = typename policy::layer_30::model;
196 using model_34 = typename policy::layer_34::model;
197 using model_38 = typename policy::layer_38::model;
198 using model_44 = typename policy::layer_44::model;
199 using model_48 = typename policy::layer_48::model;
200 using model_52 = typename policy::layer_52::model;
201 using model_class_c = dcnnsol::feature_weights< g_channel_policy, labels_channel_policy, PP>;
202 using model_class_b = dcnnsol::feature_bias< labels_channel_policy, PP>;
203
204 model_00 m_00;
205 model_04 m_04;
206 model_08 m_08;
207 model_12 m_12;
208 model_16 m_16;
209 model_20 m_20;
210 model_26 m_26;
211 model_30 m_30;
212 model_34 m_34;
213 model_38 m_38;
214 model_44 m_44;
215 model_48 m_48;
216 model_52 m_52;
217 model_class_c m_class_c;
218 model_class_b m_class_b;
219 };
220
225 template< is_policy PP>
226 class combined_data {
227 public:
228 using policy = combined_policy< PP>;
229
230 using data_input = batch_data< xxxl_image_policy, rgb_channel_policy>;
231 using internal_input_n = first_stat;
232 using data_input_n = dcnnsol::image_data< first_data_policy, PP>;
233 using internal_00 = typename policy::layer_00::internal_data;
234 using data_00r = dcnnsol::image_data< xxl_e_data_policy, PP>;
235 using internal_04 = typename policy::layer_04::internal_data;
236 using data_04r = dcnnsol::image_data< xl_f_data_policy, PP>;
237 using internal_08 = typename policy::layer_08::internal_data;
238 using data_08r = dcnnsol::image_data< xl_f_data_policy, PP>;
239 using internal_12 = typename policy::layer_12::internal_data;
240 using data_12r = dcnnsol::image_data< l_f_data_policy, PP>;
241 using internal_16 = typename policy::layer_16::internal_data;
242 using data_16r = dcnnsol::image_data< l_f_data_policy, PP>;
243 using internal_20 = typename policy::layer_20::internal_data;
244 using data_20r = dcnnsol::image_data< l_f_data_policy, PP>;
245 using data_24_p = dcnnsol::image_data< m_f_data_policy, PP>;
246 using internal_26 = typename policy::layer_26::internal_data;
247 using data_26r = typename policy::layer_26::output_data;
248 using internal_30 = typename policy::layer_30::internal_data;
249 using data_30r = typename policy::layer_30::output_data;
250 using internal_34 = typename policy::layer_34::internal_data;
251 using data_34r = typename policy::layer_34::output_data;
252 using internal_38 = typename policy::layer_38::internal_data;
253 using data_38r = dcnnsol::image_data< m_h_data_policy, PP>;
254 using data_42_p = dcnnsol::image_data< s_h_data_policy, PP>;
255 using internal_44 = typename policy::layer_44::internal_data;
256 using data_44r = dcnnsol::image_data< s_j_data_policy, PP>;
257 using internal_48 = typename policy::layer_48::internal_data;
258 using data_48r = dcnnsol::image_data< s_g_data_policy, PP>;
259 using internal_52 = typename policy::layer_52::internal_data;
260 using data_52r = dcnnsol::image_data< s_g_data_policy, PP>;
261 using data_final_p = dcnnsol::feature_data< g_channel_policy, PP>;
262 using data_class_c = dcnnsol::feature_data< labels_channel_policy, PP>;
263 using data_class_b = dcnnsol::feature_data< labels_channel_policy, PP>;
264
265 gold_data g;
266 data_input d_input;
267
268 data_input_n d_input_n;
269 data_00r d_00r;
270 data_04r d_04r;
271 data_08r d_08r;
272 data_12r d_12r;
273 data_16r d_16r;
274 data_20r d_20r;
275 data_24_p d_24_p;
276 data_26r d_26r;
277 data_30r d_30r;
278 data_34r d_34r;
279 data_38r d_38r;
280 data_42_p d_42_p;
281 data_44r d_44r;
282 data_48r d_48r;
283 data_52r d_52r;
284 data_final_p d_final_p;
285 data_class_c d_class_c;
286 data_class_b d_class_b;
287
288 internal_input_n i_input_n;
289 internal_00 i_00;
290 internal_04 i_04;
291 internal_08 i_08;
292 internal_12 i_12;
293 internal_16 i_16;
294 internal_20 i_20;
295 internal_26 i_26;
296 internal_30 i_30;
297 internal_34 i_34;
298 internal_38 i_38;
299 internal_44 i_44;
300 internal_48 i_48;
301 internal_52 i_52;
302
303 loss_data d_loss;
304
305 combined_data(const batch_range& br)
306 : g(br),
307 d_input(br),
308 d_input_n(br),
309 d_00r(br),
310 d_04r(br),
311 d_08r(br),
312 d_12r(br),
313 d_16r(br),
314 d_20r(br),
315 d_24_p(br),
316 d_26r(br),
317 d_30r(br),
318 d_34r(br),
319 d_38r(br),
320 d_42_p(br),
321 d_44r(br),
322 d_48r(br),
323 d_52r(br),
324 d_final_p(br),
325 d_class_c(br),
326 d_class_b(br),
327 i_00(br),
328 i_04(br),
329 i_08(br),
330 i_12(br),
331 i_16(br),
332 i_20(br),
333 i_26(br),
334 i_30(br),
335 i_34(br),
336 i_38(br),
337 i_44(br),
338 i_48(br),
339 i_52(br),
340 d_loss(br)
341 {
342 }
343 };
344
347
348 template< is_policy PP>
349 inline void combined_load_model(combined_model< PP>& m, const std::filesystem::path& data_folder)
350 {
351 using policy = combined_policy< PP>;
352
353 policy::layer_00::load_model(m.m_00, data_folder, 0);
354 policy::layer_04::load_model(m.m_04, data_folder, 4);
355 policy::layer_08::load_model(m.m_08, data_folder, 8);
356 policy::layer_12::load_model(m.m_12, data_folder, 12);
357 policy::layer_16::load_model(m.m_16, data_folder, 16);
358 policy::layer_20::load_model(m.m_20, data_folder, 20);
359 policy::layer_26::load_model(m.m_26, data_folder, 26);
360 policy::layer_30::load_model(m.m_30, data_folder, 30);
361 policy::layer_34::load_model(m.m_34, data_folder, 34);
362 policy::layer_38::load_model(m.m_38, data_folder, 38);
363 policy::layer_44::load_model(m.m_44, data_folder, 44);
364 policy::layer_48::load_model(m.m_48, data_folder, 48);
365 policy::layer_52::load_model(m.m_52, data_folder, 52);
366 policy::layer_class_c::load_model(m.m_class_c, data_folder, "classifier.weight");
367 policy::layer_class_b::load_model(m.m_class_b, data_folder, "classifier.bias");
368 }
369
384 template< typename mapping, is_policy PP>
385 inline float combined_forward(const test_images_t& test_images, const test_labels_t& test_labels, mapping&& bmap, const combined_model< PP>& m, combined_data< PP>& d)
386 {
387 using policy = combined_policy< PP>;
388
389 d.g.init(test_labels, bmap);
390 d.d_input.init(test_images, bmap);
391
392 policy::layer_input_n::forward(d.d_input, d.i_input_n, d.d_input_n);
393
394 policy::layer_00::forward(d.d_input_n, m.m_00, d.i_00, d.d_00r);
395
396 policy::layer_04::forward(d.d_00r, m.m_04, d.i_04, d.d_04r);
397
398 policy::layer_08::forward(d.d_04r, m.m_08, d.i_08, d.d_08r);
399
400 policy::layer_12::forward(d.d_08r, m.m_12, d.i_12, d.d_12r);
401
402 policy::layer_16::forward(d.d_12r, m.m_16, d.i_16, d.d_16r);
403
404 policy::layer_20::forward(d.d_16r, m.m_20, d.i_20, d.d_20r);
405 policy::layer_24_p::forward(d.d_20r, d.d_24_p);
406
407 policy::layer_26::forward(d.d_24_p, m.m_26, d.i_26, d.d_26r);
408
409 policy::layer_30::forward(d.d_26r, m.m_30, d.i_30, d.d_30r);
410
411 policy::layer_34::forward(d.d_30r, m.m_34, d.i_34, d.d_34r);
412
413 policy::layer_38::forward(d.d_34r, m.m_38, d.i_38, d.d_38r);
414 policy::layer_42_p::forward(d.d_38r, d.d_42_p);
415
416 policy::layer_44::forward(d.d_42_p, m.m_44, d.i_44, d.d_44r);
417
418 policy::layer_48::forward(d.d_44r, m.m_48, d.i_48, d.d_48r);
419
420 policy::layer_52::forward(d.d_48r, m.m_52, d.i_52, d.d_52r);
421
422 policy::layer_final_p::forward(d.d_52r, d.d_final_p);
423 policy::layer_class_c::forward(d.d_final_p, m.m_class_c, d.d_class_c);
424 policy::layer_class_b::forward(d.d_class_c, m.m_class_b, d.d_class_b);
425
426 policy::loss::forward(d.d_class_b, d.g, d.d_loss);
427
428 float total_loss = 0.0f;
429 for (auto x : d.d_loss.loss.range())
430 {
431 total_loss += d.d_loss.loss[x];
432 }
433
434 return total_loss;
435 }
436
438 template< is_policy PP>
439 inline std::size_t combined_forward_complexity(const batch_range& br)
440 {
441 using policy = combined_policy< PP>;
442 std::size_t s = 0;
443
444 s += policy::layer_input_n::forward_complexity(br);
445
446 s += policy::layer_00::forward_complexity(br);
447
448 s += policy::layer_04::forward_complexity(br);
449
450 s += policy::layer_08::forward_complexity(br);
451
452 s += policy::layer_12::forward_complexity(br);
453
454 s += policy::layer_16::forward_complexity(br);
455
456 s += policy::layer_20::forward_complexity(br);
457 s += policy::layer_24_p::forward_complexity(br);
458
459 s += policy::layer_26::forward_complexity(br);
460
461 s += policy::layer_30::forward_complexity(br);
462
463 s += policy::layer_34::forward_complexity(br);
464
465 s += policy::layer_38::forward_complexity(br);
466 s += policy::layer_42_p::forward_complexity(br);
467
468 s += policy::layer_44::forward_complexity(br);
469
470 s += policy::layer_48::forward_complexity(br);
471
472 s += policy::layer_52::forward_complexity(br);
473
474 s += policy::layer_final_p::forward_complexity(br);
475 s += policy::layer_class_c::forward_complexity(br);
476 s += policy::layer_class_b::forward_complexity(br);
477
478 s += policy::loss::forward_complexity(br);
479
480 return s;
481 }
483
485
489
496 template< is_policy PP>
497 class global_state {
498 public:
499 test_labels_t test_labels;
500 test_images_t test_images;
502 batch_range br;
503
504 global_state(std::size_t batch_size)
505 : br(batch_size)
506 {
507 }
508
509 void read_data(const std::filesystem::path& data_folder)
510 {
511 test_images = load_data_raw_auto<idp::image_carrier, input_tag, idp::height_tag, idp::width_tag, idp::channel_tag>(data_folder / "input.bin");
512 test_labels = load_data_raw_auto<gold_labels_policy::label_carrier, input_tag>(data_folder / "input-class.bin");
513
514 if (test_images.range().get<input_tag>() != test_labels.range().get<input_tag>())
515 throw std::runtime_error("Input data size mismatch");
516 }
517
518 void init(std::mt19937_64& eng)
519 {
520 }
521
522 void load_model(const std::filesystem::path& data_folder)
523 {
524 combined_load_model<PP>(m, data_folder);
525 }
526
527 std::size_t input_size() const
528 {
529 return test_labels.range().size();
530 }
531 };
532
539 template< is_policy PP>
540 class thread_state {
541 public:
542 batch_mapping bmap;
544 float loss;
545
546 thread_state(const global_state<PP>& gs)
547 : bmap(gs.br), d(gs.br), loss(0.0f)
548 {
549 }
550
551 template< typename IIG>
552 void minibatch_init(IIG&& input_index_generator)
553 {
554 for (auto b : bmap.range())
555 {
556 auto i = input_index_generator();
557 bmap[b] = i;
558 }
559 }
560
561 void minibatch_run(const global_state<PP>& gs)
562 {
563 loss = combined_forward(gs.test_images, gs.test_labels, bmap, gs.m, d);
564 }
565
566 void minibatch_collect(global_state<PP>& gs)
567 {
568 }
569
570 std::size_t minibatch_run_complexity(const global_state<PP>&)
571 {
572 auto fc = combined_forward_complexity<PP>(bmap.range());
573 return fc;
574 }
575
576 };
577
578}
579
580#endif
Input data, forward-propagated activations, and loss of the complete network.
Definition dcnncombined.hpp:226
Model data (weights and biases) of the complete network.
Definition dcnncombined.hpp:184
The global state, shared by all threads.
Definition dcnncombined.hpp:497
Loss data class.
Definition dcnnelements.hpp:461
A tensor - a multi-dimensional tagged generalization of vector/matrix.
Definition tagged.hpp:1365
const range_class< TL ... > & range() const
The range corresponding to this tensor.
Definition tagged.hpp:1458
constexpr std::size_t LABELS
Number of categories (digits)
Definition dcnncombined.hpp:56
tagged::range_class< batch_tag > batch_range
The range of images within a minibatch.
Definition dcnnelements.hpp:83
float combined_forward(const test_images_t &test_images, const test_labels_t &test_labels, mapping &&bmap, const combined_model< PP > &m, combined_data< PP > &d)
The forward-propagation function of the complete network.
Definition dcnncombined.hpp:385
Channel size policy.
Definition dcnnelements.hpp:334
Policy: The complete network.
Definition dcnncombined.hpp:156
Policy class: Convolution kernel dimensions.
Definition dcnnelements.hpp:689
Policy: Internal activation channels.
Definition dcnncombined.hpp:94
Policy: Internal activation channels.
Definition dcnncombined.hpp:98
Definition dcnncombined.hpp:130
Policy: Internal activation channels.
Definition dcnncombined.hpp:102
Policy: Internal activation channels.
Definition dcnncombined.hpp:106
Combined image and channel size policy.
Definition dcnnelements.hpp:352
Image size policy.
Definition dcnnelements.hpp:120
Policy: Internal activation channels.
Definition dcnncombined.hpp:110
Definition dcnncombined.hpp:133
Policy: Image after the third strided convolution layer (12)
Definition dcnncombined.hpp:73
Policy: Final linear layer channels.
Definition dcnncombined.hpp:114
Definition dcnncombined.hpp:134
Definition dcnncombined.hpp:135
Definition dcnncombined.hpp:136
Policy: Image after the first MaxPool layer (24)
Definition dcnncombined.hpp:77
Policy: Input image channels.
Definition dcnncombined.hpp:86
Definition dcnncombined.hpp:121
Policy: Input image channels.
Definition dcnncombined.hpp:90
Definition dcnncombined.hpp:139
Definition dcnncombined.hpp:137
Policy: Image after the second MaxPool layer (42)
Definition dcnncombined.hpp:81
Definition dcnncombined.hpp:138
Policy: Convolution kernel size.
Definition dcnncombined.hpp:119
Definition dcnncombined.hpp:132
Policy: Image after the second strided convolution layer (04)
Definition dcnncombined.hpp:69
Definition dcnncombined.hpp:131
Policy: Image after the first strided convolution layer (00)
Definition dcnncombined.hpp:65
Policy: Input image size.
Definition dcnncombined.hpp:61