ae2f_docs
Slp.auto.h
1#undef __ae2f_MACRO_GENERATED
2#define __ae2f_MACRO_GENERATED 1
3#ifndef ae2f_Ann_Slp_c
4#if !__ae2f_MACRO_GENERATED
5#include <ae2f/Ann/Slp.h>
6#undef __ae2f_MACRO_GENERATED
7#define __ae2f_MACRO_GENERATED 1
8#endif
9
10#define ae2f_Ann_Slp_c
11
12#include <stdlib.h>
13#undef __ae2f_MACRO_GENERATED
14#define __ae2f_MACRO_GENERATED 1
15#include <assert.h>
16#undef __ae2f_MACRO_GENERATED
17#define __ae2f_MACRO_GENERATED 1
18
19#define __ae2f_AnnSlpDel free
20#define __ae2f_AnnSlpDel_C free
21
22#if ae2f_NEED_CLASS
23#define __ae2f_AnnSlpInitInpSz_imp(
24 /** tparam */
25
26
27 /** param */
28 /* , size_t */ rret_init,
29 /* const bool */ prm_weight_opt,
30 /* const bool */ prm_bias_opt,
31 /* const bool */ prm_cache_opt,
32 /* const bool */ prm_cacheact_opt,
33 /* const size_t */ prm_inc,
34 /* const size_t */ prm_outc \
35)\
36{
37 (rret_init) =
38 sizeof(ae2f_AnnSlp)
39 + ((prm_weight_opt) ? 0 : (prm_inc) * (prm_outc)) * sizeof(ae2f_float_t)
40 + ((prm_bias_opt) ? 0 : (prm_outc)) * sizeof(ae2f_float_t)
41 + ((prm_cache_opt) ? 0 : (prm_outc) * sizeof(ae2f_float_t))
42 + ((prm_cacheact_opt) ? 0 : (prm_outc) * sizeof(ae2f_float_t))
43 ; \
44}
45
46#define __ae2f_AnnSlpInit_imp(
47 /** tparam */
48
49
50 /** param */
51 /* , size_t */ reg_init,
52 /* ae2f_AnnSlpREG_t */ rret_this,
53 /* const size_t */ prm_inc,
54 /* const size_t */ prm_outc,
55 /* const size_t */ prm_incmax_opt \
56)\
57{
58 /* Calculate maximum input size */
59 unless(prm_incmax_opt) {
60 __ae2f_AnnSlpInitInpSz_imp(
61 reg_init, 0, 0, 0, 0, prm_inc, prm_outc
62 );
63 (rret_this).m_inc = (prm_inc);
64 } else {
65 (rret_this).m_inc = (prm_incmax_opt);
66 }
67
68 (rret_this).m_outc = (prm_outc); \
69}
70
71
72#define __ae2f_AnnSlpInit_V(
73 /** tparam */
74 v_reg_init,
75
76 /** param */
77 /* ,ae2f_AnnSlp_t* const */ pret_slp,
78 /* const size_t */ prm_inc,
79 /* const size_t */ prm_outc,
80 /* const size_t */ prm_offset_opt,
81 /* ae2f_err_t* const */ pret_err_opt,
82 /* size_t* const */ pret_initsz_opt \
83)\
84{
85 if((pret_err_opt) && *(pret_err_opt))
86 ;
87 unless(pret_slp)
88 (pret_err_opt) && (*(pret_err_opt) |= ae2f_errGlob_PTR_IS_NULL);
89 else {
90 ae2f_reg size_t v_reg_init;
91 __ae2f_AnnSlpInit_imp(
92 v_reg_init
93 , *(pret_slp)
94 , prm_inc, prm_outc
95 , 0
96 );
97 (pret_initsz_opt) && (*(pret_initsz_opt) = v_reg_init + prm_offset_opt);
98 } \
99}
100
101#define __ae2f_AnnSlpInit(
102 /** tparam */
103
104
105 /** param */
106 /* ,ae2f_AnnSlp_t* const */ pret_slp,
107 /* const size_t */ prm_inc,
108 /* const size_t */ prm_outc,
109 /* const size_t */ prm_offset_opt,
110 /* ae2f_err_t* const */ pret_err_opt,
111 /* size_t* const */ pret_initsz_opt \
112)\
113{
114 __ae2f_AnnSlpInit_V(
115 v_reg_init, pret_slp
116 , prm_inc, prm_outc
117 , prm_offset_opt
118 , pret_err_opt
119 , pret_initsz_opt
120 ); \
121}
122
123#else
124#undef __ae2f_AnnSlpInitInpSz_imp
125#define __ae2f_AnnSlpInitInpSz_imp(...)
126 typedef char NO_ae2f_NEED_CLASS[-1]
127
128#undef __ae2f_AnnSlpInit_imp
129#define __ae2f_AnnSlpInit_imp(...)
130 typedef char NO_ae2f_NEED_CLASS[-1]
131
132#undef __ae2f_AnnSlpInit
133#define __ae2f_AnnSlpInit(...)
134 typedef char NO_ae2f_NEED_CLASS[-1]
135#endif
136
137
138
139#define __ae2f_AnnSlpInit_C __ae2f_AnnSlpInit
140
141#if ae2f_NEED_CLASS
142#define __ae2f_AnnSlpMkVerbose_imp(
143 /** tparam */
144
145
146 /** param */
147 /* , ae2f_AnnSlpMk_t */ reg_mk,
148 /* ae2f_float_t* const */ prop_weight_opt,
149 /* ae2f_float_t* const */ prop_bias_opt,
150 /* ae2f_float_t* const */ prop_cache_opt,
151 /* ae2f_float_t* const */ prop_cacheact_opt,
152 /* const size_t */ prm_inc,
153 /* const size_t */ prm_outc,
154 /* const size_t */ prm_offset_opt,
155 /* const size_t */ prm_extra_opt,
156 /* ae2f_optae2f_AnnActFFN_t* const */ fn_act,
157 /* ae2f_optae2f_AnnActFFN_t* const */ fn_actderiv,
158 /* ae2f_AnnLossFFN_t* const */ fn_lossderiv,
159 /* const ae2f_float_t */ prm_learningrate,
160 /* const ae2f_float_t */ prm_learningrate_bias \
161)\
162{
163 __ae2f_AnnSlpInitInpSz_imp(
164 reg_mk.m_stack
165 , prop_weight_opt
166 , prop_bias_opt
167 , prop_cache_opt
168 , prop_cacheact_opt
169 , prm_inc, prm_outc
170 );
171 if((reg_mk.m_ptr = ae2f_reinterpret_cast(
172 ae2f_AnnSlp*
173 , calloc((reg_mk).m_stack + (prm_offset_opt) + (prm_extra_opt), 1)))
174 ) {
175 (reg_mk).m_alloccount = 0;
176 (reg_mk).m_fieldptr.b = (reg_mk).m_ptr + 1;
177 (reg_mk).m_fieldptr.b = ae2f_reinterpret_cast(
178 ae2f_AnnSlp*
179 , ae2f_reinterpret_cast(char*, (reg_mk).m_fieldptr.b) + (prm_offset_opt)
180 );
181
182 if(prop_weight_opt) {
183 (reg_mk).m_ptr->m_weight = (prop_weight_opt);
184 } else {
185 (reg_mk).m_ptr->m_weight = ((reg_mk).m_fieldptr.a);
186 (reg_mk).m_fieldptr.a += (prm_inc) * (prm_outc);
187 }
188
189 if(prop_bias_opt) {
190 (reg_mk).m_ptr->m_bias = (prop_bias_opt);
191 } else {
192 (reg_mk).m_ptr->m_bias = (reg_mk).m_fieldptr.a;
193 (reg_mk).m_fieldptr.a += (prm_outc);
194 }
195
196 if(prop_cache_opt) {
197 (reg_mk).m_ptr->m_cachedelta = (prop_cache_opt);
198 } else {
199 (reg_mk).m_ptr->m_cachedelta = (reg_mk).m_fieldptr.a;
200 (reg_mk).m_fieldptr.a += (prm_outc);
201 }
202
203 if(prop_cacheact_opt) {
204 (reg_mk).m_ptr->m_cacheact = (prop_cacheact_opt);
205 } else {
206 (reg_mk).m_ptr->m_cacheact = (reg_mk).m_fieldptr.a;
207 }
208
209 __ae2f_AnnSlpInit_imp(
210 (reg_mk).m_stack
211 , reg_mk.m_ptr->m_Slp[0]
212 , prm_inc
213 , prm_outc
214 , prm_inc
215 );
216
217 (reg_mk).m_ptr[0].m_act = fn_act;
218 (reg_mk).m_ptr[0].m_actderiv = fn_actderiv;
219 (reg_mk).m_ptr[0].m_lossderiv = fn_lossderiv;
220 (reg_mk).m_ptr[0].m_learningrate = prm_learningrate;
221 (reg_mk).m_ptr[0].m_learningrate_bias = prm_learningrate_bias;
222 } \
223}
224
225#define __ae2f_AnnSlpMk(
226 /** tparam */
227
228
229 /** param */
230 /* ,ae2f_float_t* const */ weight_opt,
231 /* ae2f_float_t* const */ bias_opt,
232 /* ae2f_float_t* const */ cache_opt,
233 /* const size_t */ inc,
234 /* const size_t */ outc,
235 /* const size_t */ offset_opt,
236 /* const size_t */ extra_opt,
237 /* ae2f_AnnSlp** const */ slp,
238 /* ae2f_optae2f_AnnActFFN_t* const */ act,
239 /* ae2f_optae2f_AnnActFFN_t* const */ actderiv,
240 /* ae2f_AnnLossFFN_t* const */ lossderiv,
241 /* ae2f_float_t */ learningrate,
242 /* ae2f_float_t */ learningrate_bias,
243 /* ae2f_optae2f_err_t* const */ err_opt \
244)\
245{
246 if((err_opt) && *(err_opt))
247 ;
248 else unless(slp)
249 (err_opt) && (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL);
250 else {
251 ae2f_reg ae2f_AnnSlpMk_t v_mk;
252 __ae2f_AnnSlpMk_imp(
253 v_mk
254 , weight_opt, bias_opt, cache_opt
255 , inc
256 , outc, offset_opt, extra_opt
257 , act, actderiv, lossderiv
258 , learningrate, learningrate_bias
259 );
260
261 (err_opt) && !(*(slp) = v_mk.m_ptr) &&
262 (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL);
263 } \
264}
265#else
266#undef __ae2f_AnnSlpMk_imp
267#define __ae2f_AnnSlpMk_imp(...)
268 typedef char NO_ae2f_NEED_CLASS[-1]
269
270#undef __ae2f_AnnSlpMk
271#define __ae2f_AnnSlpMk(...)
272 typedef char NO_ae2f_NEED_CLASS[-1]
273#endif
274
275#define __ae2f_AnnSlpMk_C __ae2f_AnnSlpMk
276
277
278#define __ae2f_AnnSlpPredict_imp(
279 /** tparam */
280
281
282 /** param */
283 /* , ae2f_AnnSlpPredict_t */ reg_predict,
284 /* const ae2f_AnnSlpREG_t */ prmreg_slp,
285 /* constae2f_float_t* const */ pprm_in,
286 /* ae2f_float_t* const */ ret,
287 /* ae2f_float_t* const */ ptr_outcache,
288 /* constae2f_float_t* const */ pprm_weight,
289 /* constae2f_float_t* const */ pprm_bias,
290 /* ae2f_AnnActFFN_t */ fn_act \
291)\
292{
293 for((reg_predict).m_i = (prmreg_slp).m_outc; (reg_predict).m_i--; )
294 {
295 (reg_predict).m_ret = 0;
296
297 for((reg_predict).m_j = (prmreg_slp).m_inc; (reg_predict).m_j--; ) {
298 (reg_predict).m_ret
299 += (pprm_in)[(reg_predict).m_j]
300 * ((pprm_weight) + (reg_predict).m_i * (prmreg_slp).m_inc)[(reg_predict).m_j];
301 }
302
303 (ptr_outcache)[(reg_predict).m_i] = (reg_predict).m_ret + (pprm_bias)[(reg_predict).m_i];
304 }
305
306 for((reg_predict).m_i = (prmreg_slp).m_outc; (reg_predict).m_i--;) {
307 fn_act(&(ret)[(reg_predict).m_i], (ptr_outcache), (reg_predict).m_i, (prmreg_slp).m_outc);
308 } \
309}
310
311#define __ae2f_AnnSlpPredict(
312 /** tparam */
313
314
315 /** param */
316 /* ,ae2f_err_t* const */ err_opt,
317 /* constae2f_AnnSlp_t* const */ _this,
318 /* constae2f_float_t* const */ prm_in,
319 /* ae2f_float_t* const */ out,
320 /* ae2f_float_t* const */ out_cache,
321 /* constae2f_float_t* const */ weight,
322 /* constae2f_float_t* const */ bias,
323 /* ae2f_AnnActFFN_t */ act_opt \
324)\
325{
326 if((err_opt) && *(err_opt))
327 ;
328 else unless((_this) && (prm_in) && (out) && (weight) && (bias))
329 (err_opt) && ((err_opt) && (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL));
330 else {
331 ae2f_reg ae2f_AnnSlpPredictREG_t v_predict;
332
333 if(act_opt) {
334 __ae2f_AnnSlpPredict_imp(
335 (v_predict)
336 , *(_this), (prm_in), out, out_cache
337 , weight, bias, act_opt
338 );
339 } else {
340 __ae2f_AnnSlpPredict_imp(
341 (v_predict)
342 , *(_this), (prm_in), out, out_cache
343 , weight, bias, ae2f_AnnActFFN_PASS
344 );
345 }
346 } \
347}
348
349#if ae2f_NEED_CLASS
350#define __ae2f_AnnSlpPredict_C(
351 /** tparam */
352
353
354 /** param */
355 /* ,ae2f_err_t* const */ err_opt,
356 /* constae2f_AnnSlp* const */ _this,
357 /* constae2f_float_t* const */ prm_in,
358 /* ae2f_float_t* const */ out \
359)\
360{
361 unless(_this)
362 (err_opt) && (*(err_opt) |= ae2f_errGlob_PTR_IS_NULL);
363 else {
364 __ae2f_AnnSlpPredict(
365 err_opt, (_this)->m_Slp
366 , prm_in, out
367 , (_this)->m_cacheact
368 , (_this)->m_weight
369 , (_this)->m_bias
370 , (_this)->m_act
371 );
372 } \
373}
374#else
375#undef __ae2f_AnnSlpPredict_C
376#define __ae2f_AnnSlpPredict_C(...)
377 typedef char NO_ae2f_NEED_CLASS[-1]
378#endif
379
380/** @brief Weights */
381#define __ae2f_AnnSlpFollowOneW_imp(
382 /** tparam */
383
384
385 /** param */
386 /* , const ae2f_float_t */ inp,
387 /* const ae2f_float_t */ delta,
388 /* ae2f_float_t* const */ weight,
389 /* const ae2f_float_t */ learningrate,
390 /* const size_t */ inp_sz,
391 /* const size_t */ inp_idx,
392 /* const size_t */ out_sz,
393 /* const size_t */ out_idx \
394)\
395{
396 ((weight) + (inp_sz) * (out_idx))[(inp_idx)]
397 -= (delta) * (inp) * (learningrate); \
398}
399
400#define __ae2f_AnnSlpFollowOneB_imp(
401 /** tparam */
402
403
404 /** param */
405 /* , ae2f_float_t */ rret_bias,
406 /* const ae2f_float_t */ prm_delta,
407 /* const ae2f_float_t */ prm_learningrate_bias \
408){ (rret_bias) -= (prm_delta) * (prm_learningrate_bias); }
409
410#define __ae2f_AnnSlpFollowOne_imp(
411 /** tparam */
412
413
414 /** param */
415 /* , ae2f_AnnSlpFollowOneREG_t */ reg_follow,
416 /* constae2f_float_t* */ pprm_in,
417 /* const ae2f_float_t */ pprm_delta,
418 /* ae2f_float_t* const */ ptr_weight,
419 /* const ae2f_float_t */ prm_learningrate,
420 /* const ae2f_float_t */ prm_learningrate_bias,
421 /* const size_t */ prm_isz,
422 /* const size_t */ prm_oidx,
423 /* ae2f_float_t */ rret_bias \
424)\
425{
426 for((reg_follow).m_j = (prm_isz); (reg_follow).m_j--; ) {
427 ((ptr_weight) + (prm_isz) * (prm_oidx))[(reg_follow).m_j]
428 -= (pprm_delta) * (pprm_in)[(reg_follow).m_j] * (prm_learningrate);
429 }
430
431 (rret_bias) -= (pprm_delta) * (prm_learningrate_bias); \
432}
433
434
435#define __ae2f_AnnSlpFollow_imp(
436 /** tparam */
437
438
439 /** param */
440 /* , ae2f_AnnSlpFollowREG_t */ reg_follow,
441 /* const ae2f_AnnSlpREG_t */ prm_slp,
442 /* constae2f_float_t* const */ pprm_in,
443 /* constae2f_float_t* const */ pprm_delta,
444 /* ae2f_float_t* const */ ptr_weight,
445 /* ae2f_float_t* const */ ptr_bias,
446 /* const ae2f_float_t */ prm_learningrate,
447 /* const ae2f_float_t */ prm_learningrate_bias \
448)\
449{
450 for((reg_follow).m_i = (prm_slp).m_outc; (reg_follow).m_i--; ) {
451 __ae2f_AnnSlpFollowOne_imp(
452 reg_follow
453 , pprm_in
454 , (pprm_delta)[(reg_follow).m_i]
455 , ((ptr_weight))
456 , prm_learningrate, prm_learningrate_bias
457 , (prm_slp).m_inc
458 , (reg_follow).m_i
459 , (ptr_bias)[(reg_follow).m_i]
460 );
461 } \
462}
463
464#define __ae2f_AnnSlpFollow(
465 /** tparam */
466
467
468 /** param */
469 /* ,ae2f_err_t* const */ reterr_opt,
470 /* constae2f_AnnSlp_t* const */ _this,
471 /* constae2f_float_t* const */ prm_in,
472 /* constae2f_float_t* const */ delta,
473 /* ae2f_float_t* const */ weight,
474 /* ae2f_float_t* const */ bias,
475 /* const ae2f_float_t */ learningrate,
476 /* const ae2f_float_t */ learningrate_bias \
477)\
478{
479 if((reterr_opt) && *(reterr_opt))
480 ;
481 else if(learningrate == 0 && learningrate_bias == 0)
482 ;
483 else unless((_this) && (prm_in) && (delta) && (weight) && (bias))
484 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_PTR_IS_NULL);
485 else {
486 ae2f_reg ae2f_AnnSlpFollow_t v_follow;
487 __ae2f_AnnSlpFollow_imp(
488 v_follow
489 , *(_this)
490 , prm_in
491 , delta
492 , weight, bias
493 , learningrate
494 , learningrate_bias
495 );
496 } \
497}
498
499#if ae2f_NEED_CLASS
500#define __ae2f_AnnSlpFollow_C(
501 /** tparam */
502
503
504 /** param */
505 /* ,ae2f_err_t* const */ reterr_opt,
506 /* constae2f_AnnSlp* const */ _this,
507 /* constae2f_float_t* const */ prm_in,
508 /* constae2f_float_t* const */ delta \
509){
510 unless((_this))
511 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_PTR_IS_NULL);
512 else {
513 __ae2f_AnnSlpFollow(
514 reterr_opt, _this->m_Slp
515 , prm_in, delta
516 , _this->m_weight
517 , (_this)->m_bias
518 , (_this)->m_learningrate, (_this)->m_learningrate_bias
519 );
520 } \
521}
522#else
523#undef __ae2f_AnnSlpFollow_C
524#define __ae2f_AnnSlpFollow_C(...)
525 typedef char NO_ae2f_NEED_CLASS[-1]
526#endif
527
528#define __ae2f_AnnSlpFetchDeltaOne_imp(
529 /** tparam */
530
531
532 /** param */
533 /* , ae2f_float_t */ rret,
534 /* ae2f_float_t* const */ ptr_tmp0,
535 /* ae2f_float_t* const */ ptr_tmp1,
536 /* constae2f_float_t* const */ prm_out,
537 /* constae2f_float_t* const */ prm_out_desired,
538 /* const size_t */ prm_oidx,
539 /* const size_t */ prm_osz,
540 /* ae2f_AnnActFFN_t */ fn_actderiv,
541 /* ae2f_AnnLossFFN_t */ fn_lossderiv \
542)\
543{
544 fn_actderiv(ptr_tmp0, prm_out, prm_oidx, prm_osz);
545 fn_lossderiv(ptr_tmp1, prm_out, prm_out_desired, prm_oidx, prm_osz);
546
547 (rret) = *(ptr_tmp0) * *(ptr_tmp1); \
548}
549
550#define __ae2f_AnnSlpFetchDeltaVerbose_imp(
551 /** tparam */
552
553
554 /** param */
555 /* , ae2f_AnnSlpFetchDeltaRAM_t */ ram_delta,
556 /* ae2f_AnnSlpFetchDeltaREG_t */ reg_delta,
557 /* const ae2f_AnnSlpREG_t */ prm_slp,
558 /* constae2f_float_t* const */ pprm_out,
559 /* constae2f_float_t* const */ pprm_out_desired,
560 /* ae2f_AnnActFFN_t */ fn_actderiv,
561 /* ae2f_AnnLossFFN_t */ fn_lossderiv,
562 /* ae2f_float_t* const */ pret_delta \
563)\
564{
565 for((reg_delta).m_i = (prm_slp).m_outc; (reg_delta).m_i--; )
566 {
567 fn_actderiv(
568 &(ram_delta).m_tmp1
569 , (pprm_out)
570 , (reg_delta).m_i
571 , (prm_slp).m_outc
572 );
573
574 fn_lossderiv(
575 &(ram_delta).m_tmp
576 , (pprm_out)
577 , (pprm_out_desired)
578 , (reg_delta).m_i, (prm_slp).m_outc
579 );
580
581 (pret_delta)[(reg_delta).m_i]
582 = (ram_delta).m_tmp * (ram_delta).m_tmp1;
583 } \
584}
585
586#define __ae2f_AnnSlpFetchDelta_imp(
587 /** tparam */
588
589
590 /** param */
591 /* , ae2f_AnnSlpFetchDelta_t */ tmp_delta,
592 /* const ae2f_AnnSlpREG_t */ prm_slp,
593 /* constae2f_float_t* const */ pprm_out,
594 /* constae2f_float_t* const */ pprm_out_desired,
595 /* ae2f_AnnActFFN_t */ fn_actderiv,
596 /* ae2f_AnnLossFFN_t */ fn_lossderiv,
597 /* ae2f_float_t* const */ pret_delta \
598)\
599{
600 __ae2f_AnnSlpFetchDeltaVerbose_imp(
601 tmp_delta, tmp_delta
602 , prm_slp
603 , pprm_out, pprm_out_desired
604 , fn_actderiv, fn_lossderiv
605 , pret_delta
606 ); \
607}
608
609#define __ae2f_AnnSlpFetchDelta(
610 /** tparam */
611
612
613 /** param */
614 /* , ae2f_optae2f_err_t* const */ err,
615 /* constae2f_AnnSlp_t* const */ slp,
616 /* constae2f_float_t* const */ out,
617 /* constae2f_float_t* const */ out_desired,
618 /* ae2f_AnnActFFN_t */ actderiv_opt,
619 /* ae2f_AnnLossFFN_t */ lossderiv,
620 /* ae2f_float_t* const */ retdelta \
621) \
622{
623 if((err) && *(err))
624 ;
625 else unless((slp) && (out) && (out_desired) && (retdelta))
626 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
627 else unless(lossderiv)
628 (err) && (*(err) |= ae2f_errGlob_IMP_NOT_FOUND);
629
630 else {
631 ae2f_AnnSlpFetchDeltaRAM_t v_ram_delta;
632 ae2f_reg ae2f_AnnSlpFetchDeltaREG_t v_reg_delta;
633
634 if(actderiv_opt) {
635 __ae2f_AnnSlpFetchDeltaVerbose_imp(
636 v_ram_delta
637 , v_reg_delta
638 , (*(slp))
639 , out, out_desired
640 , actderiv_opt
641 , lossderiv
642 , retdelta
643 );
644 }
645 else {
646 __ae2f_AnnSlpFetchDeltaVerbose_imp(
647 v_ram_delta
648 , v_reg_delta
649 , (*(slp))
650 , out, out_desired
651 , ae2f_AnnActDerivFFN_PASS
652 , lossderiv
653 , retdelta
654 );
655 }
656 } \
657}
658
659#if ae2f_NEED_CLASS
660#define __ae2f_AnnSlpFetchDelta_C(
661 /** tparam */
662
663
664 /** param */
665 /* , ae2f_optae2f_err_t* const */ err,
666 /* constae2f_AnnSlp* const */ slp,
667 /* constae2f_float_t* const */ out,
668 /* constae2f_float_t* const */ out_desired,
669 /* ae2f_float_t* const */ retdelta \
670)\
671{
672 if((err) && *(err))
673 ;
674 else unless((slp) && (out) && (out_desired) && (retdelta))
675 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
676 else unless((slp)->m_lossderiv)
677 (err) && (*(err) |= ae2f_errGlob_IMP_NOT_FOUND);
678 else {
679 ae2f_AnnSlpFetchDeltaRAM_t v_ram_delta;
680 ae2f_AnnSlpFetchDeltaREG_t v_reg_delta;
681
682 if((slp)->m_actderiv) {
683 __ae2f_AnnSlpFetchDeltaVerbose_imp(
684 v_ram_delta, v_reg_delta, (slp)->m_Slp[0]
685 , out, out_desired
686 , (slp)->m_actderiv, (slp)->m_lossderiv
687 , retdelta
688 );
689 } else {
690 __ae2f_AnnSlpFetchDeltaVerbose_imp(
691 v_ram_delta, v_reg_delta, (slp)->m_Slp[0]
692 , out, out_desired
693 , ae2f_AnnActDerivFFN_PASS, (slp)->m_lossderiv
694 , retdelta
695 );
696 }
697 } \
698}
699#else
700#undef __ae2f_AnnSlpFetchDelta_C
701#define __ae2f_AnnSlpFetchDelta_C(...)
702 typedef char NO_ae2f_NEED_CLASS[-1]
703#endif
704
705
706#define __ae2f_AnnSlpFitVerbose_imp(
707 /** tparam */
708
709
710 /** param */
711 /* , ae2f_AnnSlpFitRAM_t */ ram_fit,
712 /* ae2f_AnnSlpFitREG_t */ reg_fit,
713 /* const ae2f_AnnSlp_t */ prm_slp,
714 /* constae2f_float_t* const */ pprm_inp,
715 /* constae2f_float_t* const */ pprm_out,
716 /* constae2f_float_t* const */ pprm_out_desired,
717 /* ae2f_float_t* const */ ptr_weights,
718 /* ae2f_float_t* const */ ptr_bias,
719 /* ae2f_float_t* const */ ptr_cachedelta,
720 /* ae2f_AnnActFFN_t */ fn_actderiv,
721 /* ae2f_AnnLossFFN_t */ fn_lossderiv,
722 /* const ae2f_float_t */ prm_learningrate,
723 /* const ae2f_float_t */ prm_learningrate_bias \
724)\
725{
726 __ae2f_AnnSlpFetchDeltaVerbose_imp(
727 ram_fit, reg_fit, prm_slp
728 , pprm_out, pprm_out_desired
729 , fn_actderiv, fn_lossderiv
730 , ptr_cachedelta
731 );
732
733 __ae2f_AnnSlpFollow_imp(
734 reg_fit, prm_slp, pprm_inp
735 , ptr_cachedelta, ptr_weights, ptr_bias
736 , prm_learningrate, prm_learningrate_bias
737 ); \
738}
739
740#define __ae2f_AnnSlpFit_imp(
741 /** tparam */
742
743
744 /** param */
745 /* , ae2f_AnnSlpFit_t */ v_fit,
746 /* const ae2f_AnnSlp_t */ prm_slp,
747 /* constae2f_float_t* const */ pprm_inp,
748 /* constae2f_float_t* const */ pprm_out,
749 /* constae2f_float_t* const */ pprm_out_desired,
750 /* ae2f_float_t* const */ ptr_weights,
751 /* ae2f_float_t* const */ ptr_bias,
752 /* ae2f_float_t* const */ ptr_cachedelta,
753 /* ae2f_AnnActFFN_t */ fn_actderiv,
754 /* ae2f_AnnLossFFN_t */ fn_lossderiv,
755 /* const ae2f_float_t */ prm_learningrate,
756 /* const ae2f_float_t */ prm_learningrate_bias \
757)\
758{
759 __ae2f_AnnSlpFitVerbose_imp(
760 v_fit, v_fit
761 , prm_slp
762 , pprm_inp, pprm_out, pprm_out_desired
763 , ptr_weights, ptr_bias, ptr_cachedelta
764 , fn_actderiv, fn_lossderiv
765 , prm_learningrate, prm_learningrate_bias
766 ); \
767}
768
769#define __ae2f_AnnSlpFit(
770 /** tparam */
771
772
773 /** param */
774 /* ,ae2f_err_t* const ae2f_opt */ reterr_opt,
775 /* constae2f_AnnSlpREG_t* */ _this,
776 /* constae2f_float_t* const */ prm_inp,
777 /* constae2f_float_t* const */ prm_out,
778 /* constae2f_float_t* const */ prm_out_desired,
779 /* ae2f_float_t* const */ weights,
780 /* ae2f_float_t* const */ bias,
781 /* ae2f_float_t* const */ cachedelta,
782 /* ae2f_AnnActFFN_t ae2f_opt */ actderiv_opt,
783 /* ae2f_AnnLossFFN_t */ lossderiv,
784 /* const ae2f_float_t */ learningrate,
785 /* const ae2f_float_t */ learningrate_bias \
786)\
787{
788 if((reterr_opt) && *(reterr_opt))
789 ;
790 else unless((_this) && (prm_inp) && (prm_out_desired) && (weights) && (bias) && (cachedelta))
791 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_PTR_IS_NULL);
792 else unless(lossderiv)
793 (reterr_opt) && (*(reterr_opt) |= ae2f_errGlob_IMP_NOT_FOUND);
794 else if ((learningrate) == 0 && (learningrate_bias) == 0)
795 ;
796 else {
797 ae2f_AnnSlpFitRAM_t v_ram_fit;
798 ae2f_reg ae2f_AnnSlpFitREG_t v_reg_fit;
799
800 if(actderiv_opt) {
801 __ae2f_AnnSlpFitVerbose_imp(
802 v_ram_fit
803 , v_reg_fit
804 , (*(_this))
805 , prm_inp
806 , prm_out
807 , prm_out_desired
808 , weights
809 , bias
810 , cachedelta
811 , actderiv_opt
812 , lossderiv
813 , learningrate
814 , learningrate_bias
815 );
816 } else {
817 __ae2f_AnnSlpFitVerbose_imp(
818 v_ram_fit
819 , v_reg_fit
820 , (*(_this))
821 , prm_inp
822 , prm_out
823 , prm_out_desired
824 , weights
825 , bias
826 , cachedelta
827 , ae2f_AnnActDerivFFN_PASS
828 , lossderiv
829 , learningrate
830 , learningrate_bias
831 );
832 }
833 } \
834}
835
836#if ae2f_NEED_CLASS
837#define __ae2f_AnnSlpFit_C(
838 /** tparam */
839
840
841 /** param */
842 /* ,ae2f_err_t* const */ reterr_opt,
843 /* constae2f_AnnSlp* const */ _this,
844 /* constae2f_float_t* const */ prm_inp,
845 /* constae2f_float_t* const */ prm_out,
846 /* constae2f_float_t* const */ prm_out_desired \
847){
848 unless(_this) {
849 ((reterr_opt) && (*(reterr_opt)|= ae2f_errGlob_PTR_IS_NULL));
850 }
851 else {
852 __ae2f_AnnSlpFit(
853 reterr_opt
854 , (_this)->m_Slp
855 , prm_inp
856 , prm_out
857 , prm_out_desired
858 , (_this)->m_weight
859 , (_this)->m_bias
860 , (_this)->m_cachedelta
861 , (_this)->m_actderiv
862 , (_this)->m_lossderiv
863 , (_this)->m_learningrate
864 , (_this)->m_learningrate_bias
865 );
866 } \
867}
868#else
869#undef __ae2f_AnnSlpFit_C
870#define __ae2f_AnnSlpFit_C(...)
871 typedef char NO_ae2f_NEED_CLASS[-1]
872#endif
873
874#define __ae2f_AnnSlpTrainVerbose_imp(
875 /** tparam */
876
877
878 /** param */
879 /* , ae2f_AnnSlpTrainRAM_t */ ram_train,
880 /* ae2f_AnnSlpTrainREG_t */ reg_train,
881 /* const ae2f_AnnSlp_t */ prm_slp,
882 /* constae2f_float_t* const */ pprm_inp,
883 /* ae2f_float_t* const */ pret_out,
884 /* ae2f_float_t* const */ ptr_out_cache,
885 /* constae2f_float_t* const */ pprm_out_desired,
886 /* ae2f_float_t* const */ ptr_weights,
887 /* ae2f_float_t* const */ ptr_bias,
888 /* ae2f_float_t* const */ ptr_cachedelta,
889 /* ae2f_opt ae2f_AnnActFFN_t */ fn_act,
890 /* ae2f_opt ae2f_AnnActFFN_t */ fn_actderiv,
891 /* ae2f_AnnLossFFN_t */ fn_lossderiv,
892 /* const ae2f_float_t */ prm_learningrate,
893 /* const ae2f_float_t */ prm_learningrate_bias \
894)\
895{
896 __ae2f_AnnSlpPredict_imp(
897 reg_train
898 , prm_slp
899 , pprm_inp
900 , pret_out
901 , ptr_out_cache
902 , ptr_weights
903 , ptr_bias
904 , fn_act
905 );
906
907 __ae2f_AnnSlpFitVerbose_imp(
908 ram_train
909 , reg_train
910 , prm_slp
911 , pprm_inp
912 , pret_out
913 , pprm_out_desired
914 , ptr_weights, ptr_bias, ptr_cachedelta
915 , fn_actderiv, fn_lossderiv
916 , prm_learningrate, prm_learningrate_bias
917 ); \
918}
919
920#define __ae2f_AnnSlpTrain_imp(
921 /** tparam */
922
923
924 /** param */
925 /* , ae2f_AnnSlpTrain_t */ tmp_train,
926 /* const ae2f_AnnSlp_t */ prm_slp,
927 /* constae2f_float_t* const */ pprm_inp,
928 /* ae2f_float_t* const */ pret_out,
929 /* ae2f_float_t* const */ ptr_out_cache,
930 /* constae2f_float_t* const */ pprm_out_desired,
931 /* ae2f_float_t* const */ ptr_weights,
932 /* ae2f_float_t* const */ ptr_bias,
933 /* ae2f_float_t* const */ ptr_cachedelta,
934 /* ae2f_opt ae2f_AnnActFFN_t */ fn_act,
935 /* ae2f_opt ae2f_AnnActFFN_t */ fn_actderiv,
936 /* ae2f_AnnLossFFN_t */ fn_lossderiv,
937 /* const ae2f_float_t */ prm_learningrate,
938 /* const ae2f_float_t */ prm_learningrate_bias \
939)\
940{
941 __ae2f_AnnSlpTrainVerbose_imp(
942 tmp_train, tmp_train
943 , prm_slp
944 , pprm_inp, pret_out
945 , ptr_out_cache, pprm_out_desired
946 , ptr_weights, ptr_bias, ptr_cachedelta
947 , fn_act, fn_actderiv, fn_lossderiv
948 , prm_learningrate, prm_learningrate_bias
949 ); \
950}
951
952#if ae2f_NEED_CLASS
953#define __ae2f_AnnSlpTrain_C(
954 /** tparam */
955
956
957 /** param */
958 /* ,ae2f_err_t* const */ err,
959 /* ae2f_AnnSlp* */ slp,
960 /* constae2f_float_t* */ inp,
961 /* constae2f_float_t* */ out_desired \
962)\
963{
964 unless(slp)
965 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
966 else {
967 __ae2f_AnnSlpTrain(
968 err, (slp)->m_Slp, inp
969 , (slp)->m_cacheact
970 , out_desired
971 , (slp)->m_weight
972 , (slp)->m_bias
973 , (slp)->m_cachedelta
974 , (slp)->m_act
975 , (slp)->m_actderiv
976 , (slp)->m_lossderiv
977 , (slp)->m_learningrate
978 , (slp)->m_learningrate_bias
979 );
980 } \
981}
982#else
983#undef __ae2f_AnnSlpTrain_C
984#define __ae2f_AnnSlpTrain_C
985 typedef char NO_ae2f_NEED_CLASS[-1]
986
987#endif
988
989#define __ae2f_AnnSlpTrain(
990 /** tparam */
991
992
993 /** param */
994 /* ,ae2f_err_t* const */ err,
995 /* constae2f_AnnSlpREG_t* const */ slp,
996 /* constae2f_float_t* const */ inp,
997 /* ae2f_float_t* const */ out_cache,
998 /* constae2f_float_t* const */ out_desired,
999 /* ae2f_float_t* const */ weights,
1000 /* ae2f_float_t* const */ bias,
1001 /* ae2f_float_t* const */ cachedelta,
1002 /* ae2f_optae2f_AnnActFFN_t* const */ act,
1003 /* ae2f_optae2f_AnnActFFN_t* const */ actderiv,
1004 /* ae2f_AnnLossFFN_t* const */ lossderiv,
1005 /* const ae2f_float_t */ learningrate,
1006 /* const ae2f_float_t */ learningrate_bias \
1007)\
1008{
1009 if((err) && *(err))
1010 ;
1011 else unless((slp) && (inp) && (out_cache) && (out_desired) && (weights) && (bias) && (cachedelta))
1012 (err) && (*(err) |= ae2f_errGlob_PTR_IS_NULL);
1013 else unless(lossderiv)
1014 (err) && (*(err) |= ae2f_errGlob_IMP_NOT_FOUND);
1015 else if((learningrate) == 0 && (learningrate_bias) == 0)
1016 ;
1017 else {
1018 ae2f_reg ae2f_AnnSlpTrainREG_t v_reg_train;
1019 ae2f_AnnSlpTrainRAM_t v_ram_train;
1020
1021 if (act) {
1022 if(actderiv) {
1023 __ae2f_AnnSlpTrainVerbose_imp(
1024 v_ram_train, v_reg_train
1025 , (*slp), inp, out_cache, out_cache
1026 , out_desired, weights, bias
1027 , cachedelta, act, actderiv, lossderiv
1028 , learningrate, learningrate_bias
1029 );
1030 } else {
1031 __ae2f_AnnSlpTrainVerbose_imp(
1032 v_ram_train, v_reg_train
1033 , (*slp), inp, out_cache, out_cache
1034 , out_desired, weights, bias
1035 , cachedelta, act, ae2f_AnnActDerivFFN_PASS, lossderiv
1036 , learningrate, learningrate_bias
1037 );
1038
1039 }
1040 } else {
1041 if(actderiv) {
1042 __ae2f_AnnSlpTrainVerbose_imp(
1043 v_ram_train, v_reg_train
1044 , (*slp), inp, out_cache, out_cache
1045 , out_desired, weights, bias
1046 , cachedelta, ae2f_AnnActFFN_PASS, actderiv, lossderiv
1047 , learningrate, learningrate_bias
1048 );
1049 } else {
1050 __ae2f_AnnSlpTrainVerbose_imp(
1051 v_ram_train, v_reg_train
1052 , (*slp), inp, out_cache, out_cache
1053 , out_desired, weights, bias
1054 , cachedelta, ae2f_AnnActFFN_PASS, ae2f_AnnActDerivFFN_PASS, lossderiv
1055 , learningrate, learningrate_bias
1056 );
1057
1058 }
1059 }
1060 } \
1061}
1062
1063
1064#endif
1065
1066#undef __ae2f_MACRO_GENERATED
1067
1068#define __ae2f_MACRO_GENERATED 0
ae2f_AnnActDerivFFN_PASS
#define ae2f_AnnActDerivFFN_PASS(r, o, i, c)
Definition Act.h:28
ae2f_AnnActFFN_PASS
#define ae2f_AnnActFFN_PASS(r, o, i, c)
Definition Act.h:27
ae2f_structdef
#define ae2f_structdef(key, name)
Definition Cast.h:110
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_extern
#define ae2f_extern
Suggests the existence of external variable or function, in naming of C. [non-mangling].
Definition Cast.h:88
ae2f_structdef_n
#define ae2f_structdef_n(key, name,...)
Definition Cast.h:109
ae2f_reg
#define ae2f_reg
Register keyword.
Definition Reg.h:12
ae2f_WhenCXX
#define ae2f_WhenCXX(...)
Appears when the current language is C.
Definition Cxx.h:37
ae2f_NONE
#define ae2f_NONE
Literally nothing.
Definition Cxx.h:16
ae2f_LP
#define ae2f_LP(...)
Definition Guide.h:23
ae2f_FREE
#define ae2f_FREE(...)
Definition Guide.h:33
ae2f_opt
#define ae2f_opt
Definition Guide.h:26
ae2f_errGlob_ALLOC_FAILED
#define ae2f_errGlob_ALLOC_FAILED
stdlib allocating functions (malloc, calloc, realloc) has been failed.
Definition errGlob.h:40
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 Conv.auto.h:2
ae2f_MAC_BUILD
#define ae2f_MAC_BUILD
Definition Util.h:5
ae2f_NEED_CLASS
#define ae2f_NEED_CLASS
Definition Mlp.cl.c:8
OPER_NONE
#define OPER_NONE
Definition Mlp.def.c:21
OPER_NEG
#define OPER_NEG
Definition Mlp.def.c:20
__ae2f_AnnMlpSz_imp
#define __ae2f_AnnMlpSz_imp(ret_sz, outc, weightc, depth, szswap, act, actderiv, deltastream, outcache, weight, bias)
Definition Mlp.auto.h:272
__ae2f_AnnMlpBwd_imp
#define __ae2f_AnnMlpBwd_imp(v_tmp, v_send, slp_then, retdelta_then, deltaseed, actderiv_then, inp)
delta to delta
Definition Mlp.auto.h:588
__ae2f_AnnMlpHidDeltaSingle_imp
#define __ae2f_AnnMlpHidDeltaSingle_imp(v_single, slp, weight, delta, iidx)
Definition Mlp.auto.h:566
__ae2f_AnnMlpPredictStream_imp
#define __ae2f_AnnMlpPredictStream_imp(v_predict, mlp, inp, out, sz, weight, bias, outcache, act_opt)
Definition Mlp.auto.h:554
__ae2f_AnnMlpMk_imp
#define __ae2f_AnnMlpMk_imp(reg_mk, prm_depth, pprm_szvector, propptr_szswap_opt, lppfn_act_opt, lppfn_actderiv_opt, pfn_lossderiv, propptr_deltastream_opt, propptr_outcache_opt, propptr_weight_opt, propptr_bias_opt, prm_learningrate, prm_learningrate_bias, prm_offset_opt, prm_extra_opt)
Automatically allocates ae2f_AnnMlp and store its pointer at (reg_mk).m_mkbase.
Definition Mlp.auto.h:163
__ae2f_AnnMlpInitWithOutSz_imp
#define __ae2f_AnnMlpInitWithOutSz_imp(v_mlp, v_init, depth, outsz, weightsz, szvector, szswap_opt, act, actderiv, lossderiv, deltastream, outcache, weight, bias, learningrate, learningrate_bias)
Definition Mlp.auto.h:303
__ae2f_AnnMlpTrainPrimal
#define __ae2f_AnnMlpTrainPrimal(OPER_NEG, OPER_NONE, reterr, mlp, inp, out, out_desired)
Definition Mlp.auto.h:884
__ae2f_AnnMlpFollowPrimal_imp
#define __ae2f_AnnMlpFollowPrimal_imp(OPER_NEG, OPER_NONE, v_follow, mlp, inp, delta, lenv, outstream, deltacache, weight, bias, learningrate, learningrate_bias, actderiv)
Definition Mlp.auto.h:615
__ae2f_AnnMlpPredictPrimal_imp
#define __ae2f_AnnMlpPredictPrimal_imp(OPER_NEG, OPER_NONE, v_predict, mlp, inp, out, sz, weight, bias, outcache, act_opt)
layer must be more than 2
Definition Mlp.auto.h:397
__ae2f_AnnMlpTrainAutoPrimal
#define __ae2f_AnnMlpTrainAutoPrimal(OPER_NEG, OPER_NONE, reterr, mlp, inp, out_desired)
Definition Mlp.auto.h:915
__ae2f_AnnMlpPredictPrimal
#define __ae2f_AnnMlpPredictPrimal(OPER_NEG, OPER_NONE, reterr, mlp, inp, out)
Definition Mlp.auto.h:524
__ae2f_AnnMlpFollowPrimal
#define __ae2f_AnnMlpFollowPrimal(OPER_NEG, OPER_NONE, reterr, mlp, inp, delta)
Definition Mlp.auto.h:785
__ae2f_AnnMlpTrainPrimal_imp
#define __ae2f_AnnMlpTrainPrimal_imp(OPER_NEG, OPER_NONE, v_train, mlp, inp, out, out_desired, lenv, outstream, deltacache, weight, bias, learningrate, learningrate_bias, act, actderiv, lossderiv)
Definition Mlp.auto.h:822
__ae2f_AnnSlpFollow_imp
#define __ae2f_AnnSlpFollow_imp(reg_follow, prm_slp, pprm_in, pprm_delta, ptr_weight, ptr_bias, prm_learningrate, prm_learningrate_bias)
Definition Slp.auto.h:435
__ae2f_AnnSlpInit_imp
#define __ae2f_AnnSlpInit_imp(...)
Definition Slp.auto.h:129
__ae2f_AnnSlpFit_C
#define __ae2f_AnnSlpFit_C(...)
Definition Slp.auto.h:870
__ae2f_AnnSlpFollow_C
#define __ae2f_AnnSlpFollow_C(...)
Definition Slp.auto.h:524
__ae2f_AnnSlpFollowOne_imp
#define __ae2f_AnnSlpFollowOne_imp(reg_follow, pprm_in, pprm_delta, ptr_weight, prm_learningrate, prm_learningrate_bias, prm_isz, prm_oidx, rret_bias)
Definition Slp.auto.h:410
__ae2f_AnnSlpMk_imp
#define __ae2f_AnnSlpMk_imp(...)
Definition Slp.auto.h:267
__ae2f_AnnSlpFetchDelta_imp
#define __ae2f_AnnSlpFetchDelta_imp(tmp_delta, prm_slp, pprm_out, pprm_out_desired, fn_actderiv, fn_lossderiv, pret_delta)
Definition Slp.auto.h:586
__ae2f_AnnSlpTrainVerbose_imp
#define __ae2f_AnnSlpTrainVerbose_imp(ram_train, reg_train, prm_slp, pprm_inp, pret_out, ptr_out_cache, pprm_out_desired, ptr_weights, ptr_bias, ptr_cachedelta, fn_act, fn_actderiv, fn_lossderiv, prm_learningrate, prm_learningrate_bias)
Definition Slp.auto.h:874
__ae2f_AnnSlpPredict
#define __ae2f_AnnSlpPredict(err_opt, _this, prm_in, out, out_cache, weight, bias, act_opt)
Definition Slp.auto.h:311
__ae2f_AnnSlpFitVerbose_imp
#define __ae2f_AnnSlpFitVerbose_imp(ram_fit, reg_fit, prm_slp, pprm_inp, pprm_out, pprm_out_desired, ptr_weights, ptr_bias, ptr_cachedelta, fn_actderiv, fn_lossderiv, prm_learningrate, prm_learningrate_bias)
Definition Slp.auto.h:706
__ae2f_AnnSlpInit
#define __ae2f_AnnSlpInit(...)
Definition Slp.auto.h:133
__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:769
__ae2f_AnnSlpFetchDelta_C
#define __ae2f_AnnSlpFetchDelta_C(...)
Definition Slp.auto.h:701
__ae2f_AnnSlpDel_C
#define __ae2f_AnnSlpDel_C
Definition Slp.auto.h:20
__ae2f_AnnSlpTrain_C
#define __ae2f_AnnSlpTrain_C
Definition Slp.auto.h:984
__ae2f_AnnSlpInit_C
#define __ae2f_AnnSlpInit_C
Definition Slp.auto.h:139
__ae2f_AnnSlpFetchDeltaVerbose_imp
#define __ae2f_AnnSlpFetchDeltaVerbose_imp(ram_delta, reg_delta, prm_slp, pprm_out, pprm_out_desired, fn_actderiv, fn_lossderiv, pret_delta)
Definition Slp.auto.h:550
__ae2f_AnnSlpFollow
#define __ae2f_AnnSlpFollow(reterr_opt, _this, prm_in, delta, weight, bias, learningrate, learningrate_bias)
Definition Slp.auto.h:464
__ae2f_AnnSlpPredict_imp
#define __ae2f_AnnSlpPredict_imp(reg_predict, prmreg_slp, pprm_in, ret, ptr_outcache, pprm_weight, pprm_bias, fn_act)
Definition Slp.auto.h:278
__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:989
__ae2f_AnnSlpInitInpSz_imp
#define __ae2f_AnnSlpInitInpSz_imp(...)
Definition Slp.auto.h:125
__ae2f_AnnSlpMk
#define __ae2f_AnnSlpMk(...)
Definition Slp.auto.h:271
__ae2f_AnnSlpMk_C
#define __ae2f_AnnSlpMk_C
Definition Slp.auto.h:275
__ae2f_AnnSlpPredict_C
#define __ae2f_AnnSlpPredict_C(...)
Definition Slp.auto.h:376
ae2f_AnnSlpMk
#define ae2f_AnnSlpMk
Definition Slp.h:263
ae2f_AnnSlpDel
#define ae2f_AnnSlpDel
Definition Slp.h:264
ae2f_AnnSlpTrain
#define ae2f_AnnSlpTrain
Definition Slp.h:268
ae2f_AnnSlpPredict
#define ae2f_AnnSlpPredict
Definition Slp.h:265
ae2f_AnnSlpFollow
#define ae2f_AnnSlpFollow
Definition Slp.h:266
ae2f_AnnSlpFit
#define ae2f_AnnSlpFit
Definition Slp.h:267
ae2f_MAC
#define ae2f_MAC(...)
Definition mac.h:28
Generated by doxygen 1.14.0