ae2f_docs
Slp.def.cc
Go to the documentation of this file.
1#ifndef ae2f_Ann_Slp_c
2#if !__ae2f_MACRO_GENERATED
3#include <ae2f/Ann/Slp.h>
4#endif
5
6#define ae2f_Ann_Slp_c
7
8#if !(ae2f_MAC_BUILD) && ae2f_NEED_CLASS || !(__ae2f_MACRO_GENERATED)
9#include <stdlib.h>
10#include <assert.h>
11#endif /** for non-builds */
12
13#define __ae2f_AnnSlpDel free
14#define __ae2f_AnnSlpDel_C free
15
16#if ae2f_NEED_CLASS
17ae2f_MAC() _ae2f_AnnSlpInitInpSz_imp(
18 size_t v_init
19 , ae2f_float_t* const weight_opt
20 , ae2f_float_t* const bias_opt
21 , ae2f_float_t* const cache_opt
22 , const size_t inc
23 , const size_t outc
24 )
25{
26 (v_init) =
27 sizeof(ae2f_AnnSlp)
28 + ((weight_opt) ? 0 : (inc) * (outc)) * sizeof(ae2f_float_t)
29 + ((bias_opt) ? 0 : (outc)) * sizeof(ae2f_float_t)
30 + ((cache_opt) ? 0 : (outc) * sizeof(ae2f_float_t))
31 ;
32}
33
34ae2f_MAC() _ae2f_AnnSlpInit_imp(
35 size_t v_init
36 , ae2f_AnnSlp_t _this
37 , const size_t inc
38 , const size_t outc
39 , const size_t incmax_opt
40 )
41{
42 /* Calculate maximum input size */
43 unless(incmax_opt) {
44 __ae2f_AnnSlpInitInpSz_imp(
45 v_init, 0, 0, 0, inc, outc
46 );
47 (_this).m_inc = (inc);
48 } else {
49 (_this).m_inc = (incmax_opt);
50 }
51
52 (_this).m_outc = (outc);
53}
54
55
56ae2f_MAC() _ae2f_AnnSlpInit(
57 ae2f_AnnSlp_t* const _this,
58 const size_t inc,
59 const size_t outc,
60 const size_t offset_opt,
61 ae2f_err_t* const err_opt,
62 size_t* const initsz_opt
63 )
64{
65 if((err_opt) && *(err_opt))
66 ;
67 unless(_this)
68 (err_opt) && (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL);
69 else {
70 size_t v_init;
71 __ae2f_AnnSlpInit_imp(
72 v_init
73 , *(_this)
74 , inc, outc
75 , 0
76 );
77 (initsz_opt) && (*(initsz_opt) = v_init + offset_opt);
78 }
79}
80
81#else
82#undef __ae2f_AnnSlpInitInpSz_imp
83#define __ae2f_AnnSlpInitInpSz_imp(...)
84 typedef char NO_ae2f_NEED_CLASS[-1]
85
86#undef __ae2f_AnnSlpInit_imp
87#define __ae2f_AnnSlpInit_imp(...)
88 typedef char NO_ae2f_NEED_CLASS[-1]
89
90#undef __ae2f_AnnSlpInit
91#define __ae2f_AnnSlpInit(...)
92 typedef char NO_ae2f_NEED_CLASS[-1]
93#endif
94
95
96
97#define __ae2f_AnnSlpInit_C __ae2f_AnnSlpInit
98
99#if ae2f_NEED_CLASS
100ae2f_MAC() _ae2f_AnnSlpMk_imp(
101 ae2f_AnnSlpMk_t v_mk,
102
103 ae2f_float_t* const weight_opt,
104 ae2f_float_t* const bias_opt,
105 ae2f_float_t* const cache_opt,
106
107 const size_t inc,
108 const size_t outc,
109 const size_t offset_opt,
110 const size_t extra_opt,
111
112 ae2f_opt ae2f_AnnAct_t* const act,
113 ae2f_opt ae2f_AnnAct_t* const actderiv,
114 ae2f_AnnLoss_t* const lossderiv,
115
116 ae2f_float_t learningrate,
117 ae2f_float_t learningrate_bias
118 )
119{
120 __ae2f_AnnSlpInitInpSz_imp(v_mk.m_stack, weight_opt, bias_opt, cache_opt, inc, outc);
121 if((v_mk.m_ptr = ae2f_reinterpret_cast(
122 ae2f_AnnSlp*
123 , calloc((v_mk).m_stack + (offset_opt) + (extra_opt), 1)))
124 ) {
125 (v_mk).m_alloccount = 0;
126 (v_mk).m_fieldptr.b = (v_mk).m_ptr + 1;
127 (v_mk).m_fieldptr.b = ae2f_reinterpret_cast(
128 ae2f_AnnSlp*
129 , ae2f_reinterpret_cast(char*, (v_mk).m_fieldptr.b) + (offset_opt)
130 );
131
132 if(weight_opt) {
133 (v_mk).m_ptr->m_weight = (weight_opt);
134 } else {
135 (v_mk).m_ptr->m_weight = ((v_mk).m_fieldptr.a);
136 (v_mk).m_fieldptr.a += (inc) * (outc);
137 }
138
139 if(bias_opt) {
140 (v_mk).m_ptr->m_bias = (bias_opt);
141 } else {
142 (v_mk).m_ptr->m_bias = (v_mk).m_fieldptr.a;
143 (v_mk).m_fieldptr.a += (outc);
144 }
145
146 if(cache_opt) {
147 (v_mk).m_ptr->m_cache = (cache_opt);
148 } else {
149 (v_mk).m_ptr->m_cache = (v_mk).m_fieldptr.a;
150 }
151
152 __ae2f_AnnSlpInit_imp(
153 (v_mk).m_stack
154 , v_mk.m_ptr->m_Slp[0]
155 , inc
156 , outc
157 , inc
158 );
159
160 (v_mk).m_ptr[0].m_act = act;
161 (v_mk).m_ptr[0].m_actderiv = actderiv;
162 (v_mk).m_ptr[0].m_lossderiv = lossderiv;
163 (v_mk).m_ptr[0].m_learningrate = learningrate;
164 (v_mk).m_ptr[0].m_learningrate_bias = learningrate_bias;
165 }
166}
167
168ae2f_MAC() _ae2f_AnnSlpMk(
169 ae2f_float_t* const weight_opt,
170 ae2f_float_t* const bias_opt,
171 ae2f_float_t* const cache_opt,
172
173 const size_t inc,
174 const size_t outc,
175 const size_t offset_opt,
176 const size_t extra_opt,
177 ae2f_AnnSlp** const slp,
178
179 ae2f_opt ae2f_AnnAct_t* const act,
180 ae2f_opt ae2f_AnnAct_t* const actderiv,
181 ae2f_AnnLoss_t* const lossderiv,
182
183 ae2f_float_t learningrate,
184 ae2f_float_t learningrate_bias,
185
186 ae2f_opt ae2f_err_t* const err_opt
187 )
188{
189 if((err_opt) && *(err_opt))
190 ;
191 else unless(slp)
192 (err_opt) && (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL);
193 else {
194 ae2f_AnnSlpMk_t v_mk;
195 __ae2f_AnnSlpMk_imp(
196 v_mk
197 , weight_opt, bias_opt, cache_opt
198 , inc
199 , outc, offset_opt, extra_opt
200
201 , act, actderiv, lossderiv
202
203 , learningrate, learningrate_bias
204 );
205
206 (err_opt) && !(*(slp) = v_mk.m_ptr) &&
207 (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL);
208 }
209}
210#else
211#undef __ae2f_AnnSlpMk_imp
212#define __ae2f_AnnSlpMk_imp(...)
213 typedef char NO_ae2f_NEED_CLASS[-1]
214
215#undef __ae2f_AnnSlpMk
216#define __ae2f_AnnSlpMk(...)
217 typedef char NO_ae2f_NEED_CLASS[-1]
218#endif
219
220#define __ae2f_AnnSlpMk_C __ae2f_AnnSlpMk
221
222/** @param v_predict has m_ret. That is the return value. */
223ae2f_MAC() _ae2f_AnnSlpPredictOne_imp(
224 ae2f_AnnSlpPredictOne_t v_predict
225 , const ae2f_float_t* const prm_in
226 , const ae2f_float_t* const weight
227 , const ae2f_float_t bias
228 , ae2f_AnnAct_t act_opt
229 , const size_t oidx
230 , const size_t isz
231 )
232{
233 (v_predict).m_tmp = 0;
234
235 for((v_predict).m_j = (isz); (v_predict).m_j--; ) {
236 (v_predict).m_tmp
237 += (prm_in)[(v_predict).m_j]
238 * ((weight) + (oidx) * (isz))[(v_predict).m_j];
239 }
240
241 act_opt((&(v_predict).m_ret), ((v_predict).m_tmp + (bias)));
242}
243
244ae2f_MAC() _ae2f_AnnSlpPredict_imp(
245 ae2f_AnnSlpPredict_t v_predict
246 , const ae2f_AnnSlp_t _this
247 , const ae2f_float_t* const prm_in
248 , ae2f_float_t* const out
249 , const ae2f_float_t* const weight
250 , const ae2f_float_t* const bias
251 , ae2f_AnnAct_t act_opt
252 )
253{
254 for((v_predict).m_i = (_this).m_outc; (v_predict).m_i--; )
255 {
256 __ae2f_AnnSlpPredictOne_imp(
257 v_predict
258 , prm_in
259 , weight
260 , (bias)[(v_predict).m_i]
261 , act_opt
262 , (v_predict).m_i
263 , (_this).m_inc
264 );
265
266 (out)[(v_predict).m_i] = (v_predict).m_ret;
267 }
268}
269
270ae2f_MAC() _ae2f_AnnSlpPredict(
271 ae2f_err_t* const err_opt
272 , const ae2f_AnnSlp_t* const _this
273 , const ae2f_float_t* const prm_in
274 , ae2f_float_t* const out
275
276 , const ae2f_float_t* const weight
277 , const ae2f_float_t* const bias
278 , ae2f_AnnAct_t act_opt
279 )
280{
281 if((err_opt) && *(err_opt))
282 ;
283 else unless((_this) && (prm_in) && (out) && (weight) && (bias))
284 (err_opt) && ((err_opt) && (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL));
285 else {
286 ae2f_AnnSlpPredict_t v_predict;
287
288 if(act_opt) {
289 __ae2f_AnnSlpPredict_imp(
290 (v_predict)
291 , *(_this), (prm_in), out
292 , weight, bias, act_opt
293 );
294 } else {
295 __ae2f_AnnSlpPredict_imp(
296 (v_predict)
297 , *(_this), prm_in, out
298 , weight, bias,
299 );
300 }
301 }
302}
303
304#if ae2f_NEED_CLASS
305ae2f_MAC() _ae2f_AnnSlpPredict_C(
306 ae2f_err_t* const err_opt
307 , const ae2f_AnnSlp* const _this
308 , const ae2f_float_t* const prm_in
309 , ae2f_float_t* const out
310 )
311{
312 unless(_this)
313 (err_opt) && (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL);
314 else {
315 __ae2f_AnnSlpPredict(
316 err_opt, (_this)->m_Slp
317 , prm_in, out
318 , (_this)->m_weight
319 , (_this)->m_bias
320 , (_this)->m_act
321 );
322 }
323}
324#else
325#undef __ae2f_AnnSlpPredict_C
326#define __ae2f_AnnSlpPredict_C(...)
327 typedef char NO_ae2f_NEED_CLASS[-1]
328#endif
329
330/** @brief Weights */
331ae2f_MAC() _ae2f_AnnSlpFollowOneW_imp(
332 const ae2f_float_t inp
333 , const ae2f_float_t delta
334 , ae2f_float_t* const weight
335 , const ae2f_float_t learningrate
336 , const size_t inp_sz
337 , const size_t inp_idx
338 , const size_t out_sz
339 , const size_t out_idx
340 )
341{
342 ((weight) + (inp_sz) * (out_idx))[(inp_idx)]
343 -= (delta) * (inp) * (learningrate);
344}
345
346ae2f_MAC() _ae2f_AnnSlpFollowOneB_imp(
347 ae2f_float_t r_bias
348 , const ae2f_float_t delta
349 , const ae2f_float_t learningrate_bias
350 ) { (r_bias) -= (delta) * (learningrate_bias); }
351
352ae2f_MAC() _ae2f_AnnSlpFollowOne_imp(
353 ae2f_AnnSlpFollowOne_t v_follow
354 , const ae2f_float_t* prm_in
355 , const ae2f_float_t delta
356 , ae2f_float_t* const weight
357 , const ae2f_float_t learningrate
358 , const ae2f_float_t learningrate_bias
359
360 , const size_t inp_sz
361 , const size_t out_idx
362 , ae2f_float_t v_bias
363 )
364{
365 for((v_follow).m_j = 0; (v_follow).m_j < (inp_sz); ++(v_follow).m_j) {
366 ((weight) + (inp_sz) * (out_idx))[(v_follow).m_j]
367 -= (delta) * (prm_in)[(v_follow).m_j] * (learningrate);
368 }
369
370 (v_bias) -= (delta) * (learningrate_bias);
371}
372
373
374ae2f_MAC() _ae2f_AnnSlpFollow_imp(
375 ae2f_AnnSlpFollow_t v_follow
376 , const ae2f_AnnSlp_t _this
377 , const ae2f_float_t* const prm_in
378 , const ae2f_float_t* const delta
379 , ae2f_float_t* const weight
380 , ae2f_float_t* const bias
381 , const ae2f_float_t learningrate
382 , const ae2f_float_t learningrate_bias
383 )
384{
385 for(v_follow.m_i = (_this).m_outc; (v_follow).m_i--; ) {
386 __ae2f_AnnSlpFollowOne_imp(
387 v_follow
388 , prm_in
389 , (delta)[v_follow.m_i]
390 , ((weight))
391 , learningrate, learningrate_bias
392 , (_this).m_inc
393 , (v_follow).m_i
394 , (bias)[v_follow.m_i]
395 );
396 }
397}
398
399ae2f_MAC() _ae2f_AnnSlpFollow(
400 ae2f_err_t* const reterr_opt
401 , const ae2f_AnnSlp_t* const _this
402 , const ae2f_float_t* const prm_in
403 , const ae2f_float_t* const delta
404 , ae2f_float_t* const weight
405 , ae2f_float_t* const bias
406 , const ae2f_float_t learningrate
407 , const ae2f_float_t learningrate_bias
408 )
409{
410 if((reterr_opt) && *(reterr_opt))
411 ;
412 else if(learningrate == 0 && learningrate_bias == 0)
413 ;
414 else unless((_this) && (prm_in) && (delta) && (weight) && (bias))
415 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_PTR_IS_NULL);
416 else {
417 ae2f_AnnSlpFollow_t v_follow;
418 __ae2f_AnnSlpFollow_imp(
419 v_follow
420 , *(_this)
421 , prm_in
422 , delta
423 , weight, bias
424 , learningrate
425 , learningrate_bias
426 );
427 }
428}
429
430#if ae2f_NEED_CLASS
431ae2f_MAC() _ae2f_AnnSlpFollow_C(
432 ae2f_err_t* const reterr_opt
433 , const ae2f_AnnSlp* const _this
434 , const ae2f_float_t* const prm_in
435 , const ae2f_float_t* const delta
436 ) {
437 unless((_this))
438 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_PTR_IS_NULL);
439 else {
440 __ae2f_AnnSlpFollow(
441 reterr_opt, _this->m_Slp
442 , prm_in, delta
443 , _this->m_weight
444 , (_this)->m_bias
445 , (_this)->m_learningrate, (_this)->m_learningrate_bias
446 );
447 }
448}
449#else
450#undef __ae2f_AnnSlpFollow_C
451#define __ae2f_AnnSlpFollow_C(...)
452 typedef char NO_ae2f_NEED_CLASS[-1]
453#endif
454
455ae2f_MAC() _ae2f_AnnSlpFetchDeltaOne_imp(
456 ae2f_float_t v_fetchdelta_0,
457 ae2f_float_t v_fetchdelta_1,
458
459 const ae2f_float_t* const out
460 , const ae2f_float_t* const out_desired
461
462 , ae2f_AnnAct_t actderiv_opt
463 , ae2f_AnnLoss_t lossderiv
464
465 , ae2f_float_t retdelta
466 , const size_t oidx
467 , const size_t osz
468 )
469{
470 actderiv_opt(&(v_fetchdelta_0), (out)[oidx]);
471 lossderiv((&(v_fetchdelta_1)), (out), (out_desired), (oidx), (osz));
472
473 (retdelta) =
474 (v_fetchdelta_0) *
475 (v_fetchdelta_1)
476 ;
477}
478
479ae2f_MAC() _ae2f_AnnSlpFetchDelta_imp(
480 ae2f_AnnSlpFetchDelta_t v_delta
481 , const ae2f_AnnSlp_t slp
482
483 , const ae2f_float_t* const out
484 , const ae2f_float_t* const out_desired
485
486 , ae2f_AnnAct_t actderiv_opt
487 , ae2f_AnnLoss_t lossderiv
488
489 , ae2f_float_t* const retdelta
490 )
491{
492 for((v_delta).m_i = (slp).m_outc; (v_delta).m_i--; )
493 __ae2f_AnnSlpFetchDeltaOne_imp(
494 (v_delta).m_tmp, (v_delta).m_tmp1
495 , out, out_desired
496 , actderiv_opt, lossderiv
497 , (retdelta)[v_delta.m_i]
498 , (v_delta).m_i
499 , (slp).m_outc
500 );
501}
502
503ae2f_MAC() _ae2f_AnnSlpFetchDelta(
504 ae2f_opt ae2f_err_t* const err
505 , const ae2f_AnnSlp_t* const slp
506
507 , const ae2f_float_t* const out
508 , const ae2f_float_t* const out_desired
509
510 , ae2f_AnnAct_t actderiv_opt
511 , ae2f_AnnLoss_t lossderiv
512
513 , ae2f_float_t* const retdelta
514 )
515{
516 if((err) && *(err))
517 ;
518 else unless((slp) && (out) && (out_desired) && (retdelta))
519 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
520 else unless(lossderiv)
521 (err) && (*(err) |= ae2f_errGlob_IMP_NOT_FOUND);
522
523 else if(actderiv_opt) {
524 ae2f_AnnSlpFetchDelta_t v_delta;
525 __ae2f_AnnSlpFetchDelta_imp(
526 v_delta, (*(slp))
527 , out, out_desired
528 , actderiv_opt
529 , lossderiv
530 , retdelta
531 );
532 } else {
533 ae2f_AnnSlpFetchDelta_t v_delta;
534 __ae2f_AnnSlpFetchDelta_imp(
535 v_delta, (*(slp))
536 , out, out_desired
537 , , lossderiv
538 , retdelta
539 );
540 }
541}
542
543#if ae2f_NEED_CLASS
544ae2f_MAC() _ae2f_AnnSlpFetchDelta_C(
545 ae2f_opt ae2f_err_t* const err
546 , const ae2f_AnnSlp* const slp
547
548 , const ae2f_float_t* const out
549 , const ae2f_float_t* const out_desired
550
551 , ae2f_float_t* const retdelta
552 )
553{
554 if((err) && *(err))
555 ;
556 else unless((slp) && (out) && (out_desired) && (retdelta))
557 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
558 else unless((slp)->m_lossderiv)
559 (err) && (*(err) |= ae2f_errGlob_IMP_NOT_FOUND);
560 else {
561 if((slp)->m_actderiv) {
562 ae2f_AnnSlpFetchDelta_t v_delta;
563 __ae2f_AnnSlpFetchDelta_imp(
564 v_delta, (slp)->m_Slp[0]
565 , out, out_desired
566 , (slp)->m_actderiv, (slp)->m_lossderiv
567 , retdelta
568 );
569 } else {
570 ae2f_AnnSlpFetchDelta_t v_delta;
571 __ae2f_AnnSlpFetchDelta_imp(
572 v_delta, (slp)->m_Slp[0]
573 , out, out_desired
574 , , (slp)->m_lossderiv
575 , retdelta
576 );
577 }
578 }
579}
580#else
581#undef __ae2f_AnnSlpFetchDelta_C
582#define __ae2f_AnnSlpFetchDelta_C(...)
583 typedef char NO_ae2f_NEED_CLASS[-1]
584#endif
585
586ae2f_MAC() _ae2f_AnnSlpFitOne_imp(
587 ae2f_AnnSlpFitOne_t v_fit
588
589 , const ae2f_float_t* const inp
590 , const ae2f_float_t* const out
591 , const ae2f_float_t* const out_desired
592 , ae2f_float_t* const weight
593
594 , ae2f_float_t r_bias
595 , ae2f_float_t r_cachedelta
596
597 , ae2f_AnnAct_t actderiv_opt
598 , ae2f_AnnLoss_t lossderiv
599
600 , const ae2f_float_t learningrate
601 , const ae2f_float_t learningrate_bias
602
603 , const size_t iidx
604 , const size_t oidx
605
606 , const size_t isz
607, const size_t osz
608)
609{
610 __ae2f_AnnSlpFetchDeltaOne_imp(
611 (v_fit).m_tmp, (v_fit).m_tmp1
612 , out, out_desired
613 , actderiv_opt, lossderiv
614 , r_cachedelta
615 , oidx, osz
616 );
617
618
619 __ae2f_AnnSlpFollowOne_imp(
620 v_fit, inp, r_cachedelta, weight
621 , learningrate, learningrate_bias
622 , isz, oidx, r_bias
623 );
624}
625
626ae2f_MAC() _ae2f_AnnSlpFit_imp(
627 ae2f_AnnSlpFit_t v_fit
628
629 , const ae2f_AnnSlp_t slp
630
631 , const ae2f_float_t* const inp
632 , const ae2f_float_t* const out
633 , const ae2f_float_t* const out_desired
634
635 , ae2f_float_t* const weights
636 , ae2f_float_t* const bias
637 , ae2f_float_t* const cachedelta
638
639 , ae2f_AnnAct_t actderiv_opt
640 , ae2f_AnnLoss_t lossderiv
641
642 , const ae2f_float_t learningrate
643 , const ae2f_float_t learningrate_bias
644 )
645{
646 __ae2f_AnnSlpFetchDelta_imp(
647 v_fit, slp
648 , out, out_desired
649 , actderiv_opt, lossderiv
650 , cachedelta
651 );
652
653 __ae2f_AnnSlpFollow_imp(
654 v_fit, slp, inp
655 , cachedelta, weights, bias
656 , learningrate, learningrate_bias
657 );
658}
659
660ae2f_MAC() _ae2f_AnnSlpFit(
661 ae2f_err_t* const ae2f_opt reterr_opt
662 , const ae2f_AnnSlp_t* _this
663
664 , const ae2f_float_t* const prm_inp
665 , const ae2f_float_t* const prm_out
666 , const ae2f_float_t* const prm_out_desired
667
668 , ae2f_float_t* const weights
669 , ae2f_float_t* const bias
670 , ae2f_float_t* const cachedelta
671
672 , ae2f_AnnAct_t ae2f_opt actderiv_opt
673 , ae2f_AnnLoss_t lossderiv
674
675 , const ae2f_float_t learningrate
676 , const ae2f_float_t learningrate_bias
677 )
678{
679 if((reterr_opt) && *(reterr_opt))
680 ;
681 else unless((_this) && (prm_inp) && (prm_out_desired) && (weights) && (bias) && (cachedelta))
682 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_PTR_IS_NULL);
683 else unless(lossderiv)
684 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_IMP_NOT_FOUND);
685 else if ((learningrate) == 0 && (learningrate_bias) == 0)
686 ;
687 else {
688 ae2f_AnnSlpFit_t v_fit;
689 if(actderiv_opt) {
690 __ae2f_AnnSlpFit_imp(
691 v_fit
692 , (*(_this))
693 , prm_inp
694 , prm_out
695 , prm_out_desired
696 , weights
697 , bias
698 , cachedelta
699 , actderiv_opt
700 , lossderiv
701 , learningrate
702 , learningrate_bias
703 );
704 } else {
705 __ae2f_AnnSlpFit_imp(
706 v_fit
707 , (*(_this))
708 , prm_inp
709 , prm_out
710 , prm_out_desired
711 , weights
712 , bias
713 , cachedelta
714 ,
715 , lossderiv
716 , learningrate
717 , learningrate_bias
718 );
719 }
720 }
721}
722
723#if ae2f_NEED_CLASS
724ae2f_MAC() _ae2f_AnnSlpFit_C(
725 ae2f_err_t* const reterr_opt
726 , const ae2f_AnnSlp* const _this
727 , const ae2f_float_t* const prm_inp
728 , const ae2f_float_t* const prm_out
729 , const ae2f_float_t* const prm_out_desired
730 ) {
731 unless(_this) {
732 ((reterr_opt) && (*(reterr_opt)|= ae2f_errGlob_PTR_IS_NULL));
733 }
734 else {
735 __ae2f_AnnSlpFit(
736 reterr_opt
737 , (_this)->m_Slp
738 , prm_inp
739 , prm_out
740 , prm_out_desired
741 , (_this)->m_weight
742 , (_this)->m_bias
743 , (_this)->m_cache
744 , (_this)->m_actderiv
745 , (_this)->m_lossderiv
746 , (_this)->m_learningrate
747 , (_this)->m_learningrate_bias
748 );
749 }
750}
751#else
752#undef __ae2f_AnnSlpFit_C
753#define __ae2f_AnnSlpFit_C(...)
754 typedef char NO_ae2f_NEED_CLASS[-1]
755#endif
756
757ae2f_MAC() _ae2f_AnnSlpTrainOne_imp(
758 ae2f_AnnSlpTrainOne_t v_train
759
760 , ae2f_opt ae2f_AnnAct_t act
761 , ae2f_opt ae2f_AnnAct_t actderiv
762 , ae2f_AnnLoss_t lossderiv
763
764 , const ae2f_float_t* const inp
765 , ae2f_float_t* const out_cache
766 , const ae2f_float_t* const out_desired
767
768 , ae2f_float_t* const weight
769 , ae2f_float_t v_bias
770 , ae2f_float_t r_cachedelta
771
772 , const ae2f_float_t learningrate
773 , const ae2f_float_t learningrate_bias
774
775 , const size_t oidx
776 , const size_t osz
777 , const size_t isz
778)
779{
780 __ae2f_AnnSlpPredictOne_imp(
781 v_train
782 , inp
783 , weight
784 , v_bias
785 , act
786 , oidx
787 , isz
788 );
789
790 (out_cache)[oidx] = (v_train).m_ret;
791
792 __ae2f_AnnSlpFitOne_imp(
793 v_train
794 , inp
795 , out_cache, out_desired
796 , weight
797 , v_bias
798 , r_cachedelta
799 , actderiv, lossderiv
800 , learningrate, learningrate_bias
801 , iidx, oidx, isz, osz
802 );
803}
804
805ae2f_MAC() _ae2f_AnnSlpTrain_imp(
806 ae2f_AnnSlpTrain_t v_train
807 , const ae2f_AnnSlp_t slp
808
809 , const ae2f_float_t* const inp
810 , ae2f_float_t* const out_cache
811 , const ae2f_float_t* const out_desired
812
813 , ae2f_float_t* const weights
814 , ae2f_float_t* const bias
815 , ae2f_float_t* const cachedelta
816
817 , ae2f_opt ae2f_AnnAct_t act
818 , ae2f_opt ae2f_AnnAct_t actderiv
819 , ae2f_AnnLoss_t lossderiv
820
821 , const ae2f_float_t learningrate
822 , const ae2f_float_t learningrate_bias
823 )
824{
825 __ae2f_AnnSlpPredict_imp(v_train, slp, inp, out_cache, weights, bias, act);
826 __ae2f_AnnSlpFit_imp(
827 v_train, slp, inp, out_cache, out_desired
828 , weights, bias, cachedelta
829 , actderiv, lossderiv
830 , learningrate, learningrate_bias
831 );
832}
833
834#if ae2f_NEED_CLASS
835ae2f_MAC() _ae2f_AnnSlpTrain_C(
836 ae2f_err_t* const err
837 , ae2f_AnnSlp* slp
838 , const ae2f_float_t* inp
839 , const ae2f_float_t* out_desired
840 )
841{
842 unless(slp)
843 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
844 else {
845 __ae2f_AnnSlpTrain(
846 err, (slp)->m_Slp, inp
847 , (slp)->m_cache
848 , out_desired
849 , (slp)->m_weight
850 , (slp)->m_bias
851 , (slp)->m_cache
852 , (slp)->m_act
853 , (slp)->m_actderiv
854 , (slp)->m_lossderiv
855 , (slp)->m_learningrate
856 , (slp)->m_learningrate_bias
857 );
858 }
859}
860#else
861#undef __ae2f_AnnSlpTrain_C
862#define __ae2f_AnnSlpTrain_C
863 typedef char NO_ae2f_NEED_CLASS[-1]
864
865#endif
866
867ae2f_MAC() _ae2f_AnnSlpTrain(
868 ae2f_err_t* const err
869 , const ae2f_AnnSlp_t* const slp
870
871 , const ae2f_float_t* const inp
872 , ae2f_float_t* const out_cache
873 , const ae2f_float_t* const out_desired
874
875 , ae2f_float_t* const weights
876 , ae2f_float_t* const bias
877 , ae2f_float_t* const cachedelta
878
879 , ae2f_opt ae2f_AnnAct_t* const act
880 , ae2f_opt ae2f_AnnAct_t* const actderiv
881 , ae2f_AnnLoss_t* const lossderiv
882
883 , const ae2f_float_t learningrate
884 , const ae2f_float_t learningrate_bias
885 )
886{
887 if((err) && *(err))
888 ;
889 else unless((slp) && (inp) && (out_cache) && (out_desired) && (weights) && (bias) && (cachedelta))
890 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
891 else unless(lossderiv)
892 (err) && (*(err) |= ae2f_errGlob_IMP_NOT_FOUND);
893 else if((learningrate) == 0 && (learningrate_bias) == 0)
894 ;
895 else {
896 ae2f_AnnSlpTrain_t v_train;
897 if (act) {
898 if(actderiv) {
899 __ae2f_AnnSlpTrain_imp(
900 v_train, (*slp), inp, out_cache
901 , out_desired, weights, bias
902 , cachedelta, act, actderiv, lossderiv
903 , learningrate, learningrate_bias
904 );
905 } else {
906 __ae2f_AnnSlpTrain_imp(
907 v_train, (*slp), inp, out_cache
908 , out_desired, weights, bias
909 , cachedelta, act, , lossderiv
910 , learningrate, learningrate_bias
911 );
912
913 }
914 } else {
915 if(actderiv) {
916 __ae2f_AnnSlpTrain_imp(
917 v_train, (*slp), inp, out_cache
918 , out_desired, weights, bias
919 , cachedelta, , actderiv, lossderiv
920 , learningrate, learningrate_bias
921 );
922 } else {
923 __ae2f_AnnSlpTrain_imp(
924 v_train, (*slp), inp, out_cache
925 , out_desired, weights, bias
926 , cachedelta, , , lossderiv
927 , learningrate, learningrate_bias
928 );
929
930 }
931 }
932 }
933}
934
935
936#endif
ae2f_AnnAct_t
void ae2f_AnnAct_t(ae2f_float_t *ret, ae2f_float_t x)
Customisable activasion function type.
Definition Act.h:19
ae2f_AnnLoss_t
void ae2f_AnnLoss_t(ae2f_float_t *ret, const ae2f_float_t *out, const ae2f_float_t *goal, size_t index, size_t count)
Specify the way of calculating loss.
Definition Act.h:29
ae2f_reinterpret_cast
#define ae2f_reinterpret_cast(t, v)
Definition Cast.h:52
unless
#define unless(...)
Invokes when condition is false.
Definition Cast.h:103
ae2f_float_t
ae2f_float ae2f_float_t
Definition Float.h:38
ae2f_opt
#define ae2f_opt
Definition Guide.h:26
ae2f_MAC_BUILD
#define ae2f_MAC_BUILD
Definition Util.h:4
ae2f_NEED_CLASS
#define ae2f_NEED_CLASS
Definition Mlp.cl.c:1
isz
const ae2f_float_t *const const ae2f_float_t *const const ae2f_float_t ae2f_AnnAct_t const size_t const size_t isz
Definition Slp.def.cc:232
bias
const ae2f_float_t *const const ae2f_float_t *const const ae2f_float_t bias
Definition Slp.def.cc:228
_this
const ae2f_AnnSlp_t _this
Definition Slp.def.cc:247
out
const ae2f_AnnSlp_t const ae2f_float_t *const ae2f_float_t *const out
Definition Slp.def.cc:249
act_opt
const ae2f_float_t *const const ae2f_float_t *const const ae2f_float_t ae2f_AnnAct_t act_opt
Definition Slp.def.cc:229
oidx
const ae2f_float_t *const const ae2f_float_t *const const ae2f_float_t ae2f_AnnAct_t const size_t oidx
Definition Slp.def.cc:230
weight
const ae2f_float_t *const const ae2f_float_t *const weight
Definition Slp.def.cc:227
prm_in
const ae2f_float_t *const prm_in
Definition Slp.def.cc:226
ae2f_err_t
uint8_t ae2f_err_t
Informs that this number represents the error.
Definition errGlob.h:19
ae2f_errGlob_PTR_IS_NULL
#define ae2f_errGlob_PTR_IS_NULL
Failed to refer the pointer either l-value inside the function.
Definition errGlob.h:32
ae2f_errGlob_IMP_NOT_FOUND
#define ae2f_errGlob_IMP_NOT_FOUND
Failed to find the function on preprocessor which is callable for some reason No operation has beed d...
Definition errGlob.h:28
__ae2f_MACRO_GENERATED
#define __ae2f_MACRO_GENERATED
Definition Mlp.auto.h:2
__ae2f_AnnSlpPredict
#define __ae2f_AnnSlpPredict(err_opt, _this, prm_in, out, weight, bias, act_opt)
Definition Slp.auto.h:298
__ae2f_AnnSlpInit_imp
#define __ae2f_AnnSlpInit_imp(...)
Definition Slp.auto.h:107
__ae2f_AnnSlpMk_imp
#define __ae2f_AnnSlpMk_imp(...)
Definition Slp.auto.h:232
__ae2f_AnnSlpTrain_imp
#define __ae2f_AnnSlpTrain_imp(v_train, slp, inp, out_cache, out_desired, weights, bias, cachedelta, act, actderiv, lossderiv, learningrate, learningrate_bias)
Definition Slp.auto.h:868
__ae2f_AnnSlpInit
#define __ae2f_AnnSlpInit(...)
Definition Slp.auto.h:111
__ae2f_AnnSlpFit
#define __ae2f_AnnSlpFit(reterr_opt, _this, prm_inp, prm_out, prm_out_desired, weights, bias, cachedelta, actderiv_opt, lossderiv, learningrate, learningrate_bias)
Definition Slp.auto.h:720
__ae2f_AnnSlpFit_imp
#define __ae2f_AnnSlpFit_imp(v_fit, slp, inp, out, out_desired, weights, bias, cachedelta, actderiv_opt, lossderiv, learningrate, learningrate_bias)
Definition Slp.auto.h:687
__ae2f_AnnSlpFitOne_imp
#define __ae2f_AnnSlpFitOne_imp(v_fit, inp, out, out_desired, weight, r_bias, r_cachedelta, actderiv_opt, lossderiv, learningrate, learningrate_bias, iidx, oidx, isz, osz)
Definition Slp.auto.h:649
__ae2f_AnnSlpPredictOne_imp
#define __ae2f_AnnSlpPredictOne_imp(v_predict, prm_in, weight, bias, act_opt, oidx, isz)
Definition Slp.auto.h:243
__ae2f_AnnSlpFollow_imp
#define __ae2f_AnnSlpFollow_imp(v_follow, _this, prm_in, delta, weight, bias, learningrate, learningrate_bias)
Definition Slp.auto.h:420
__ae2f_AnnSlpFollow
#define __ae2f_AnnSlpFollow(reterr_opt, _this, prm_in, delta, weight, bias, learningrate, learningrate_bias)
Definition Slp.auto.h:449
__ae2f_AnnSlpTrain
#define __ae2f_AnnSlpTrain(err, slp, inp, out_cache, out_desired, weights, bias, cachedelta, act, actderiv, lossderiv, learningrate, learningrate_bias)
Definition Slp.auto.h:934
__ae2f_AnnSlpInitInpSz_imp
#define __ae2f_AnnSlpInitInpSz_imp(...)
Definition Slp.auto.h:103
__ae2f_AnnSlpFollowOne_imp
#define __ae2f_AnnSlpFollowOne_imp(v_follow, prm_in, delta, weight, learningrate, learningrate_bias, inp_sz, out_idx, v_bias)
Definition Slp.auto.h:395
__ae2f_AnnSlpMk
#define __ae2f_AnnSlpMk(...)
Definition Slp.auto.h:236
__ae2f_AnnSlpFetchDelta_imp
#define __ae2f_AnnSlpFetchDelta_imp(v_delta, slp, out, out_desired, actderiv_opt, lossderiv, retdelta)
Definition Slp.auto.h:538
__ae2f_AnnSlpPredict_imp
#define __ae2f_AnnSlpPredict_imp(v_predict, _this, prm_in, out, weight, bias, act_opt)
Definition Slp.auto.h:268
__ae2f_AnnSlpFetchDeltaOne_imp
#define __ae2f_AnnSlpFetchDeltaOne_imp(v_fetchdelta_0, v_fetchdelta_1, out, out_desired, actderiv_opt, lossderiv, retdelta, oidx, osz)
Definition Slp.auto.h:513
ae2f_MAC
#define ae2f_MAC()
delta to delta
Definition mac.h:4
Generated by doxygen 1.14.0