ae2f_docs
Mlp.auto.h
Go to the documentation of this file.
1#undef __ae2f_MACRO_GENERATED
2#define __ae2f_MACRO_GENERATED 1
3#include <ae2f/Ann/Util.h>
4#undef __ae2f_MACRO_GENERATED
5#define __ae2f_MACRO_GENERATED 1
6
7#if !ae2f_MAC_BUILD || !__ae2f_MACRO_GENERATED
8#include <assert.h>
9#undef __ae2f_MACRO_GENERATED
10#define __ae2f_MACRO_GENERATED 1
11#include <stdlib.h>
12#undef __ae2f_MACRO_GENERATED
13#define __ae2f_MACRO_GENERATED 1
14#endif
15
16#if !__ae2f_MACRO_GENERATED
17#include <ae2f/Macro.h>
18#undef __ae2f_MACRO_GENERATED
19#define __ae2f_MACRO_GENERATED 1
20#include <ae2f/Ann/Slp.h>
21#undef __ae2f_MACRO_GENERATED
22#define __ae2f_MACRO_GENERATED 1
23#endif
24
25#ifndef ae2f_Ann_Mlp_c
26
27#if !__ae2f_MACRO_GENERATED
28#include <ae2f/Ann/Mlp.h>
29#undef __ae2f_MACRO_GENERATED
30#define __ae2f_MACRO_GENERATED 1
31#endif
32
33#if !__ae2f_MACRO_GENERATED
34#define OPER_NEG
35#define OPER_NONE
36#endif
37
38#define ae2f_Ann_Mlp_c
39
40#if ae2f_NEED_CLASS
41
42#define __ae2f_AnnMlpDel_C(a) free(ae2f_reinterpret_cast(void*, a))
43
44#define __ae2f_AnnMlpMk_C(
45 /** tparam */
46
47
48 /** param */
49 /* ,ae2f_err_t* const */ reterr,
50 /* ae2f_AnnMlp** const */ retmk,
51 /* const size_t */ depth,
52 /* constsize_t* const */ szvector,
53 /* ae2f_optsize_t* const */ szswap_opt,
54 /* ae2f_optae2f_AnnAct_t** const */ act,
55 /* ae2f_optae2f_AnnAct_t** const */ actderiv,
56 /* ae2f_AnnLoss_t* const */ lossderiv,
57 /* ae2f_optae2f_float_t* const */ deltastream,
58 /* ae2f_optae2f_float_t* const */ outcache,
59 /* ae2f_optae2f_float_t* const */ weight,
60 /* ae2f_optae2f_float_t* const */ bias,
61 /* ae2f_float_t const */ learningrate,
62 /* ae2f_float_t const */ learningrate_bias,
63 /* ae2f_opt const size_t */ offset,
64 /* ae2f_opt const size_t */ extra \
65){
66 if((reterr) && *(reterr)) {}
67 else unless((szvector) && (lossderiv) && (retmk))
68 (reterr) && (*(reterr) |= ae2f_errGlob_PTR_IS_NULL);
69 else {
70 ae2f_AnnMlpMk_t v_mk;
71 __ae2f_AnnMlpMk_imp(
72 v_mk
73 , depth, szvector, szswap_opt
74 , act, actderiv, lossderiv
75 , deltastream, outcache, weight
76 , bias, learningrate, learningrate_bias
77 , offset, extra
78 );
79
80 assert(v_mk.m_mkbase && "Initialising has failed");
81 *(retmk) = v_mk.m_mkbase;
82 unless(v_mk.m_mkbase) {
83 (reterr) && (*(reterr) |= ae2f_errGlob_ALLOC_FAILED);
84 }
85 } \
86}
87
88#else
89
90#define __ae2f_AnnMlpDel_C(...)
91 typedef char NO_ae2f_NEED_CLASS[-1]
92
93#define __ae2f_AnnMlpMk_C(...)
94 typedef char NO_ae2f_NEED_CLASS[-1]
95
96
97#endif
98
99#if ae2f_NEED_CLASS
100
101#define __ae2f_AnnMlpMk_imp(
102 /** tparam */
103
104
105 /** param */
106 /* , ae2f_AnnMlpMk_t */ v_mk,
107 /* const size_t */ depth,
108 /* constsize_t* const */ szvector,
109 /* size_t* const */ szswap_opt,
110 /* ae2f_optae2f_AnnAct_t** const */ act,
111 /* ae2f_optae2f_AnnAct_t** const */ actderiv,
112 /* ae2f_AnnLoss_t* const */ lossderiv,
113 /* ae2f_optae2f_float_t* const */ deltastream,
114 /* ae2f_optae2f_float_t* const */ outcache,
115 /* ae2f_optae2f_float_t* const */ weight,
116 /* ae2f_optae2f_float_t* const */ bias,
117 /* ae2f_float_t const */ learningrate,
118 /* ae2f_float_t const */ learningrate_bias,
119 /* ae2f_opt const size_t */ offset,
120 /* ae2f_opt const size_t */ extra \
121)\
122{
123 assert((szvector) && "Size vector is null");
124 assert((lossderiv) && "Loss deriv must be initialised");
125 assert((depth) > 2 && "Depth must be greater than 2");
126
127 (v_mk).m_outc = 2;
128 for((v_mk).m_i = (depth); (v_mk).m_i--; ) {
129 assert((szvector)[(v_mk).m_i] && "Zero value is permitted");
130 (v_mk).m_outc < (szvector)[(v_mk).m_i] && ((v_mk).m_outc = (szvector)[(v_mk).m_i]);
131 }
132
133 __ae2f_AnnMlpSz_imp(
134 (v_mk).m_i
135 , (v_mk).m_outc
136 , depth, szswap_opt
137 , act, actderiv
138 , deltastream, outcache
139 , weight, bias
140 );
141
142 (v_mk).m_mkptr.m_void = calloc(1, (v_mk).m_i + (offset) + (extra));
143 (v_mk).m_mkbase = (v_mk).m_mkptr.m_mlp;
144
145 if((v_mk).m_mkptr.m_void) {
146 __ae2f_AnnMlpInitWithOutSz_imp(
147 *(v_mk).m_mkptr.m_mlp
148 , (v_mk).m_i
149 , depth
150 , (v_mk).m_outc
151 , szvector
152 , (szswap_opt) ? (szswap_opt) : ae2f_reinterpret_cast(
153 size_t*
154 , (v_mk).m_mkptr.m_mlp + 1)
155 , act
156 , actderiv
157 , lossderiv
158 , deltastream
159 , outcache
160 , weight
161 , bias
162 , learningrate
163 , learningrate_bias
164 );
165
166 (v_mk).m_mkptr.m_mlp += 1;
167 (v_mk).m_mkptr.m_byte += (offset);
168 (v_mk).m_mkptr.m_sz += (depth);
169
170 unless(act) {
171 (v_mk).m_mkbase->m_act = (v_mk).m_mkptr.m_Act;
172 (v_mk).m_mkptr.m_Act += (depth) - 1;
173 }
174
175 unless(actderiv) {
176 (v_mk).m_mkbase->m_actderiv = (v_mk).m_mkptr.m_Act;
177 (v_mk).m_mkptr.m_Act += (depth) - 1;
178 }
179
180 unless(deltastream) {
181 (v_mk).m_mkbase->m_deltastream = (v_mk).m_mkptr.m_f;
182 (v_mk).m_mkptr.m_f += ((depth) - 1) * (v_mk).m_outc;
183 }
184
185 unless(outcache) {
186 (v_mk).m_mkbase->m_outcache = (v_mk).m_mkptr.m_f;
187 (v_mk).m_mkptr.m_f += ((depth) - 1) * (v_mk).m_outc;
188 }
189
190 unless(bias) {
191 (v_mk).m_mkbase->m_bias = (v_mk).m_mkptr.m_f;
192 (v_mk).m_mkptr.m_f += ((depth) - 1) * (v_mk).m_outc;
193 }
194
195 unless(weight) {
196 (v_mk).m_mkbase->m_weight = (v_mk).m_mkptr.m_f;
197 }
198 } \
199}
200
201#define __ae2f_AnnMlpSz_imp(
202 /** tparam */
203
204
205 /** param */
206 /* , size_t */ ret_sz,
207 /* const size_t */ outc,
208 /* const size_t */ depth,
209 /* ae2f_opt constsize_t* const */ szswap,
210 /* ae2f_optae2f_AnnAct_t** const */ act,
211 /* ae2f_optae2f_AnnAct_t** const */ actderiv,
212 /* ae2f_optae2f_float_t* const */ deltastream,
213 /* ae2f_optae2f_float_t* const */ outcache,
214 /* ae2f_optae2f_float_t* const */ weight,
215 /* ae2f_optae2f_float_t* const */ bias \
216)\
217{
218 assert((depth) > 2);
219
220 (ret_sz) = sizeof(ae2f_AnnMlp) + (!(szswap)) * sizeof(size_t);
221 (ret_sz) += (sizeof(void*) * ((depth) - 1)) * (!(act) + !(actderiv));
222 (ret_sz) += sizeof(ae2f_float_t)
223 * ((depth)) * (outc)
224 * (/**/
225 !(deltastream) + !(outcache) + !(bias)
226 + ((!(weight)) * (outc))
227 ); \
228}
229
230#define __ae2f_AnnMlpInitWithOutSz_imp(
231 /** tparam */
232
233
234 /** param */
235 /* , ae2f_AnnMlp */ v_mlp,
236 /* size_t */ v_init,
237 /* const size_t */ depth,
238 /* const size_t */ outsz,
239 /* constsize_t* const */ szvector,
240 /* size_t* const */ szswap_opt,
241 /* ae2f_optae2f_AnnAct_t** const */ act,
242 /* ae2f_optae2f_AnnAct_t** const */ actderiv,
243 /* ae2f_AnnLoss_t* const */ lossderiv,
244 /* ae2f_optae2f_float_t* const */ deltastream,
245 /* ae2f_optae2f_float_t* const */ outcache,
246 /* ae2f_optae2f_float_t* const */ weight,
247 /* ae2f_optae2f_float_t* const */ bias,
248 /* ae2f_float_t const */ learningrate,
249 /* ae2f_float_t const */ learningrate_bias \
250)\
251{
252 assert((depth) >= 2 && "At lest you need input and output layer");
253 (v_mlp).m_depth = (depth);
254 (v_mlp).m_outc = (outsz);
255
256 assert((lossderiv) && "loss deriv is null");
257 (v_mlp).m_lossderiv = lossderiv;
258
259 (v_mlp).m_sz = (szswap_opt);
260 (v_mlp).m_act = (act);
261 (v_mlp).m_actderiv = (actderiv);
262
263 (v_mlp).m_deltastream = deltastream;
264 (v_mlp).m_outcache = outcache;
265 (v_mlp).m_weight = weight;
266 (v_mlp).m_bias = bias;
267
268 (v_mlp).m_learningrate = learningrate;
269 (v_mlp).m_learningrate_bias = learningrate_bias;
270
271 if((szswap_opt) && (szswap_opt) != (szvector))
272 for((v_init) = (depth); (v_init)--; ) {
273 (szswap_opt)[(v_init)] = (szvector)[(v_init)];
274 } \
275}
276
277#define __ae2f_AnnMlpInit_imp(
278 /** tparam */
279
280
281 /** param */
282 /* , ae2f_AnnMlp */ v_mlp,
283 /* ae2f_AnnMlpInit_t */ v_init,
284 /* const size_t */ depth,
285 /* constsize_t* const */ szvector,
286 /* size_t* const */ szswap_opt,
287 /* ae2f_optae2f_AnnAct_t** const */ act,
288 /* ae2f_optae2f_AnnAct_t** const */ actderiv,
289 /* ae2f_AnnLoss_t* const */ lossderiv,
290 /* ae2f_optae2f_float_t* const */ deltastream,
291 /* ae2f_optae2f_float_t* const */ outcache,
292 /* ae2f_optae2f_float_t* const */ weight,
293 /* ae2f_optae2f_float_t* const */ bias,
294 /* ae2f_float_t const */ learningrate,
295 /* ae2f_float_t const */ learningrate_bias \
296)\
297{
298 (v_init).m_outc = 0;
299
300 assert((szvector) && "Size vector is null");
301 for((v_init).m_i = (depth); (v_init).m_i--; ) {
302 assert((szvector)[(v_init).m_i] && "Zero value is permitted");
303 (v_init).m_outc < (szvector)[(v_init).m_i] && ((v_init).m_outc = (szvector)[(v_init).m_i]);
304 }
305
306 __ae2f_AnnMlpInitWithOutSz_imp(
307 v_mlp, (v_init).m_i, depth, (v_mlp).m_outc
308 , szvector, szswap_opt, act, actderiv, lossderiv
309 , deltastream, outcache, weight, bias, learningrate, learningrate_bias
310 ); \
311}
312
313#else
314
315#define __ae2f_AnnMlpMk_imp(...)
316 typedef char NO_ae2f_NEED_CLASS[-1]
317
318#define __ae2f_AnnMlpSz_imp(...)
319 typedef char NO_ae2f_NEED_CLASS[-1]
320
321#define __ae2f_AnnMlpInitWithOutSz_imp(...)
322 typedef char NO_ae2f_NEED_CLASS[-1]
323
324#define __ae2f_AnnMlpInit_imp(...)
325 typedef char NO_ae2f_NEED_CLASS[-1]
326
327#endif
328
329/** @brief layer must be more than 2 */
330#define __ae2f_AnnMlpPredictPrimal_imp(
331 /** tparam */
332 OPER_NEG,OPER_NONE,
333
334 /** param */
335 /* , ae2f_AnnMlpPredict_t */ v_predict,
336 /* const ae2f_AnnMlp_t */ mlp,
337 /* constae2f_float_t* const */ inp,
338 /* ae2f_float_t* const */ out,
339 /* constsize_t* const */ sz,
340 /* constae2f_float_t* const */ weight,
341 /* constae2f_float_t* const */ bias,
342 /* ae2f_float_t* const */ outcache,
343 /* ae2f_AnnAct_t* const* const */ act_opt \
344)\
345{
346 assert((mlp).m_depth > 2);
347
348 (v_predict).m_depth = (mlp).m_depth - 1;
349 (v_predict).m_outc_max = (mlp).m_outc;
350
351 (v_predict).m_inc = (sz)[0];
352 (v_predict).m_outc = (sz)[1];
353
354 if((act_opt)[0]) {
355 __ae2f_AnnSlpPredict_imp(
356 (v_predict)
357 , (v_predict)
358 , inp
359 , ((outcache) + (0 OPER_NONE) * (v_predict).m_outc_max)
360 , weight
361 , bias
362 , (act_opt)[0]
363 );
364 } else {
365 __ae2f_AnnSlpPredict_imp(
366 (v_predict)
367 , (v_predict)
368 , inp
369 , (outcache + (0 OPER_NONE) * (v_predict).m_outc_max)
370 , weight
371 , bias
372 ,
373 );
374 }
375
376
377 for(
378 (v_predict).m_k = 1;
379 (v_predict).m_k < (v_predict).m_depth - 1;
380 (v_predict).m_k++
381 )
382 {
383 (v_predict).m_inc = (v_predict).m_outc;
384 (v_predict).m_outc = (sz)[(v_predict).m_k + 1];
385
386 if((act_opt)[(v_predict).m_k]) {
387 assert((v_predict).m_k);
388 assert(((v_predict).m_k OPER_NEG) != ((v_predict).m_k OPER_NONE));
389 assert(((v_predict).m_k OPER_NEG) == (((v_predict).m_k - 1) OPER_NONE));
390 assert((((v_predict).m_k + 1) OPER_NEG) == (((v_predict).m_k) OPER_NONE));
391
392 __ae2f_AnnSlpPredict_imp(
393 (v_predict)
394 , (v_predict)
395 , ((outcache) + (((v_predict).m_k OPER_NEG) * (v_predict).m_outc_max))
396 , ((outcache) + (((v_predict).m_k OPER_NONE) * (v_predict).m_outc_max))
397 , (weight) + ((v_predict).m_k) * (
398 (v_predict).m_outc_max
399 * (v_predict).m_outc_max
400 )
401 , (bias) + ((v_predict).m_k) * (v_predict).m_outc_max
402 , (act_opt)[(v_predict).m_k]
403 );
404 } else {
405 __ae2f_AnnSlpPredict_imp(
406 (v_predict)
407 , (v_predict)
408 , ((outcache) + (
409 ((v_predict).m_k OPER_NEG)
410 * (v_predict).m_outc_max
411 ))
412 , ((outcache) + (
413 ((v_predict).m_k OPER_NONE)
414 * (v_predict).m_outc_max
415 ))
416 , (weight)
417 + (((v_predict).m_k)
418 * (v_predict).m_outc_max
419 * (v_predict).m_outc_max)
420 , (bias) + ((v_predict).m_k) * (v_predict).m_outc_max
421 ,
422 );
423 }
424 }
425
426 (v_predict).m_inc = (v_predict).m_outc;
427 (v_predict).m_outc = (sz)[(v_predict).m_k + 1];
428 assert((v_predict).m_k == (mlp).m_depth - 2);
429
430 if((act_opt)[(v_predict).m_k]) {
431 __ae2f_AnnSlpPredict_imp(
432 (v_predict)
433 , (v_predict)
434 , ((outcache) + ((((v_predict).m_k OPER_NEG)) * (v_predict).m_outc_max))
435 , (out)
436 , (weight) + ((v_predict).m_k) * (v_predict).m_outc_max * (v_predict).m_outc_max
437 , (bias) + ((v_predict).m_k) * (v_predict).m_outc_max
438 , (act_opt)[(v_predict).m_k]
439 );
440 } else {
441 __ae2f_AnnSlpPredict_imp(
442 (v_predict)
443 , (v_predict)
444 , ((outcache) + ((((v_predict).m_k OPER_NEG)) * (v_predict).m_outc_max))
445 , (out)
446 , ((weight) + ((v_predict).m_k) * (v_predict).m_outc_max * (v_predict).m_outc_max)
447 , ((bias) + ((v_predict).m_k) * (v_predict).m_outc_max)
448 ,
449 );
450 } \
451}
452
453#if ae2f_NEED_CLASS
454#define __ae2f_AnnMlpPredictPrimal(
455 /** tparam */
456 OPER_NEG,OPER_NONE,
457
458 /** param */
459 /* ,ae2f_err_t* */ reterr,
460 /* constae2f_AnnMlp* const */ mlp,
461 /* constae2f_float_t* const */ inp,
462 /* ae2f_float_t* const */ out \
463) \
464{
465 if((reterr) && *(reterr))
466 ;
467 else unless((mlp) && (inp) && (out)) {
468 assert(0 && "Null");
469 (reterr) && (*(reterr) |= ae2f_errGlob_PTR_IS_NULL);
470 } else {
471 ae2f_AnnMlpPredict_t v_predict;
472
473 __ae2f_AnnMlpPredictPrimal_imp(
474 OPER_NEG, OPER_NONE
475 , v_predict, *(mlp)
476 , inp, out
477 , (mlp)->m_sz, (mlp)->m_weight
478 , (mlp)->m_bias, (mlp)->m_outcache
479 , (mlp)->m_act
480 );
481 } \
482}
483#else
484
485#define __ae2f_AnnMlpPredictPrimal(...)
486 typedef char NO_ae2f_NEED_CLASS[-1]
487
488#endif
489
490
491#define __ae2f_AnnMlpPredictStream_imp(...)
492 __ae2f_AnnMlpPredictPrimal_imp(-1, , __VA_ARGS__)
493
494#define __ae2f_AnnMlpPredictStream_C(reterr, mlp, inp, out)
495 __ae2f_AnnMlpPredictPrimal(-1, , reterr, mlp, inp, out)
496
497#define __ae2f_AnnMlpPredict_imp(...)
498 __ae2f_AnnMlpPredictPrimal_imp(&1 ? 0 : 1, &1, __VA_ARGS__)
499
500#define __ae2f_AnnMlpPredict_C(...)
501 __ae2f_AnnMlpPredictPrimal(&1 ? 0 : 1, &1, __VA_ARGS__)
502
503#define __ae2f_AnnMlpHidDeltaSingle_imp(
504 /** tparam */
505
506
507 /** param */
508 /* , ae2f_AnnMlpHidDeltaSingle_t */ v_single,
509 /* const ae2f_AnnSlp_t */ slp,
510 /* constae2f_float_t* const */ weight,
511 /* constae2f_float_t* const */ delta,
512 /* const size_t */ iidx \
513)\
514{
515 (v_single).m_ret = 0;
516
517 for((v_single).m_i = (slp).m_outc; (v_single).m_i--; )
518 {
519 (v_single).m_ret +=
520 ((weight) + (slp).m_inc * (v_single).m_i)[iidx] * (delta)[(v_single).m_i];
521 } \
522}
523
524/** @brief delta to delta */
525#define __ae2f_AnnMlpPropagate_imp(
526 /** tparam */
527
528
529 /** param */
530 /* , ae2f_float_t */ v_tmp,
531 /* size_t */ v_send,
532 /* const ae2f_AnnSlp_t */ slp_then,
533 /* ae2f_float_t* const */ retdelta_then,
534 /* constae2f_float_t* const */ deltaseed,
535 /* ae2f_AnnAct_t */ actderiv_then,
536 /* constae2f_float_t* const */ inp \
537)\
538{
539 for((v_send) = (slp_then).m_outc; (v_send)--;) {
540 actderiv_then(&(v_tmp), (inp)[v_send]);
541 (retdelta_then)[v_send] = (v_tmp) * (deltaseed)[v_send];
542 } \
543}
544
545#define __ae2f_AnnMlpFollowStream_imp(...)
546 __ae2f_AnnMlpFollowPrimal_imp(-1,ae2f_NONE,__VA_ARGS__)
547
548
549#define __ae2f_AnnMlpFollow_imp(...)
550 __ae2f_AnnMlpFollowPrimal_imp(&1 ? 0 : 1,&1, __VA_ARGS__)
551
552#define __ae2f_AnnMlpFollowPrimal_imp(
553 /** tparam */
554 OPER_NEG,OPER_NONE,
555
556 /** param */
557 /* , ae2f_AnnMlpFollow_t */ v_follow,
558 /* const ae2f_AnnMlp_t */ mlp,
559 /* constae2f_float_t* const */ inp,
560 /* constae2f_float_t* const */ delta,
561 /* constsize_t* const */ lenv,
562 /* constae2f_float_t* const */ outstream,
563 /* ae2f_float_t* const */ deltacache,
564 /* ae2f_float_t* const */ weight,
565 /* ae2f_float_t* const */ bias,
566 /* const ae2f_float_t */ learningrate,
567 /* const ae2f_float_t */ learningrate_bias,
568 /* ae2f_AnnAct_t* const* const */ actderiv \
569)\
570{
571 assert(((mlp).m_depth > 2) && "m_depth must be more than 1.");
572 assert((inp) && "inp is null");
573 assert((weight) && "weight is null");
574 assert((bias) && "bias is null");
575 assert((actderiv) && "actderiv list is null");
576 assert((delta) && "delta is null");
577 assert(lenv);
578
579 /** m_k: index for then */
580 (v_follow).m_k = (mlp).m_depth - 2;
581
582 /** permanent */
583 (v_follow).m_pg_weight = (v_follow).m_pg_out = (mlp).m_outc;
584 (v_follow).m_pg_weight *= (v_follow).m_pg_out;
585
586 (v_follow).m_outc = (lenv)[(v_follow).m_k + 1];
587 (v_follow).m_inc = (lenv)[(v_follow).m_k];
588
589 /** \
590 * out field update (delta is specified) \
591 * */
592 __ae2f_AnnSlpFollow_imp(
593 v_follow
594 , (v_follow)
595 , ((outstream) + (v_follow).m_pg_out * ((v_follow).m_k - 1))
596 , (delta)
597 , ((weight) + ((v_follow).m_pg_weight * ((v_follow).m_k)))
598 , ((bias) + ((v_follow).m_pg_out * ((v_follow).m_k)))
599 , learningrate
600 , learningrate_bias
601 );
602
603 (v_follow).m_j = (v_follow).m_inc;
604 while((v_follow).m_j--) {
605 __ae2f_AnnMlpHidDeltaSingle_imp(
606 v_follow
607 , v_follow
608 , ((weight) + ((v_follow).m_pg_weight * (v_follow).m_k))
609 , (delta)
610 , (v_follow).m_j
611 );
612
613 ((deltacache) + (v_follow).m_pg_out * ((v_follow).m_k OPER_NEG))[(v_follow).m_j]
614 = (v_follow).m_ret;
615 }
616
617 (v_follow).m_outc = (lenv)[(v_follow).m_k];
618 (v_follow).m_inc = (lenv)[(v_follow).m_k - 1];
619
620 /** nxt-delta to then-delta */
621 if((actderiv)[(v_follow).m_k - 1]) {
622 __ae2f_AnnMlpPropagate_imp(
623 (v_follow).m_ret
624 , (v_follow).m_stack.m_send
625 , (v_follow)
626 , ((deltacache) + ((v_follow).m_pg_out * ((v_follow).m_k OPER_NEG)))
627 , ((deltacache) + ((v_follow).m_pg_out * ((v_follow).m_k OPER_NEG)))
628 , (actderiv)[(v_follow).m_k - 1]
629 , ((outstream) + (v_follow).m_pg_out * ((v_follow).m_k - 1)) /** input of (v_follow).m_k */
630 );
631 } else {
632 __ae2f_AnnMlpPropagate_imp(
633 (v_follow).m_ret
634 , (v_follow).m_stack.m_send
635 , (v_follow)
636 , ((deltacache) + (((v_follow).m_pg_out) * ((v_follow).m_k OPER_NEG)))
637 , ((deltacache) + (((v_follow).m_pg_out) * ((v_follow).m_k OPER_NEG)))
638 , /** actderiv */
639 , ((outstream) + (v_follow).m_pg_out * ((v_follow).m_k - 1))
640 );
641 }
642
643
644 while(--(v_follow).m_k) {
645 assert((v_follow).m_k);
646 assert(((v_follow).m_k OPER_NEG) != ((v_follow).m_k OPER_NONE));
647 assert(((v_follow).m_k OPER_NEG) == (((v_follow).m_k - 1) OPER_NONE));
648 assert((((v_follow).m_k + 1) OPER_NEG) == (((v_follow).m_k) OPER_NONE));
649
650 /** \
651 * out field update (delta is generated) \
652 * */
653 __ae2f_AnnSlpFollow_imp(
654 (v_follow)
655 , (v_follow)
656 , ((outstream) + (v_follow).m_pg_out * ((v_follow).m_k - 1))
657 , ((deltacache) + (v_follow).m_pg_out * ((v_follow).m_k OPER_NONE))
658 , ((weight) + ((v_follow).m_pg_weight * (v_follow).m_k))
659 , ((bias) + ((v_follow).m_pg_out * ((v_follow).m_k)))
660 , learningrate
661 , learningrate_bias
662 );
663
664 (v_follow).m_j = (v_follow).m_inc;
665 assert((v_follow).m_inc == (lenv)[(v_follow).m_k]);
666
667 while((v_follow).m_j--) {
668 (v_follow).m_ret = 0;
669
670 __ae2f_AnnMlpHidDeltaSingle_imp(
671 v_follow
672 , v_follow
673 , ((weight) + (v_follow).m_pg_weight * ((v_follow).m_k))
674 , ((deltacache) + (v_follow).m_pg_out * ((v_follow).m_k OPER_NONE))
675 , (v_follow).m_j
676 );
677
678 ((deltacache) + (v_follow).m_pg_out * ((v_follow).m_k OPER_NEG))[(v_follow).m_j]
679 = (v_follow).m_ret;
680 }
681
682 (v_follow).m_outc = (v_follow).m_inc;
683 (v_follow).m_inc = (lenv)[(v_follow).m_k - 1];
684 assert((v_follow).m_outc == (lenv)[(v_follow).m_k]);
685
686 /** nxt-delta to then-delta */
687 if((actderiv)[(v_follow).m_k - 1]) {
688 __ae2f_AnnMlpPropagate_imp(
689 (v_follow).m_ret
690 , (v_follow).m_stack.m_send
691 , (v_follow)
692 , ((deltacache) + ((v_follow).m_pg_out * ((v_follow).m_k OPER_NEG)))
693 , ((deltacache) + ((v_follow).m_pg_out * ((v_follow).m_k OPER_NEG)))
694 , (actderiv)[(v_follow).m_k - 1]
695 , ((outstream) + (v_follow).m_pg_out * ((v_follow).m_k - 1))
696 );
697 } else {
698 __ae2f_AnnMlpPropagate_imp(
699 (v_follow).m_ret
700 , (v_follow).m_stack.m_send
701 , (v_follow)
702 , ((deltacache) + (((v_follow).m_pg_out) * ((v_follow).m_k OPER_NEG)))
703 , ((deltacache) + (((v_follow).m_pg_out) * ((v_follow).m_k OPER_NEG)))
704 , /** actderiv */
705 , ((outstream) + (v_follow).m_pg_out * ((v_follow).m_k - 1))
706 );
707 }
708 }
709
710 assert(((v_follow).m_k) == 0 && "(v_follow).m_k must be zero.");
711 assert((v_follow).m_inc == (lenv)[0] && "inc must be same as first element of lenv.");
712 assert((v_follow).m_outc == (lenv)[1] && "outc must be same as second element of lenv.");
713
714 __ae2f_AnnSlpFollow_imp(
715 v_follow
716 , (v_follow)
717 , (inp)
718 , ((deltacache) + (v_follow).m_pg_out * ((v_follow).m_k OPER_NONE))
719 , ((weight))
720 , (bias)
721 , learningrate
722 , learningrate_bias
723 ); \
724}
725
726#if ae2f_NEED_CLASS
727#define __ae2f_AnnMlpFollowPrimal(
728 /** tparam */
729 OPER_NEG,OPER_NONE,
730
731 /** param */
732 /* ,ae2f_err_t* const */ reterr,
733 /* constae2f_AnnMlp* */ mlp,
734 /* constae2f_float_t* const */ inp,
735 /* constae2f_float_t* const */ delta \
736) \
737{
738 if((reterr) && *(reterr)) {}
739 else unless((mlp) && (inp) && (delta)) {
740 assert(0 && "nullref");
741 (reterr) && (*(reterr) |= ae2f_errGlob_PTR_IS_NULL);
742 } else {
743 ae2f_AnnMlpFollow_t v_follow;
744
745 __ae2f_AnnMlpFollowPrimal_imp(
746 OPER_NEG, OPER_NONE
747 , v_follow
748 , *(mlp), inp, delta, (mlp)->m_sz
749 , (mlp)->m_outcache, (mlp)->m_deltastream
750 , (mlp)->m_weight
751 , (mlp)->m_bias
752 , (mlp)->m_learningrate, (mlp)->m_learningrate_bias
753 , (mlp)->m_actderiv
754 );
755 } \
756}
757
758#else
759
760#define __ae2f_AnnMlpFollowPrimal(...)
761 typedef char NO_ae2f_NEED_CLASS[-1]
762
763#endif
764
765#define __ae2f_AnnMlpFollow_C(...)
766 __ae2f_AnnMlpFollowPrimal(&1 ? 0 : 1,&1, __VA_ARGS__)
767
768#define __ae2f_AnnMlpFollowStream_C(...)
769 __ae2f_AnnMlpFollowPrimal(-1, , __VA_ARGS__)
770
771#define __ae2f_AnnMlpTrainPrimal_imp(
772 /** tparam */
773 OPER_NEG,OPER_NONE,
774
775 /** param */
776 /* , ae2f_AnnMlpTrain_t */ v_train,
777 /* const ae2f_AnnMlp_t */ mlp,
778 /* constae2f_float_t* const */ inp,
779 /* ae2f_float_t* const */ out,
780 /* constae2f_float_t* const */ out_desired,
781 /* constsize_t* const */ lenv,
782 /* ae2f_float_t* const */ outstream,
783 /* ae2f_float_t* const */ deltacache,
784 /* ae2f_float_t* const */ weight,
785 /* ae2f_float_t* const */ bias,
786 /* const ae2f_float_t */ learningrate,
787 /* const ae2f_float_t */ learningrate_bias,
788 /* ae2f_optae2f_AnnAct_t* const* const */ act,
789 /* ae2f_optae2f_AnnAct_t* const* const */ actderiv,
790 /* ae2f_AnnLoss_t* */ lossderiv \
791)\
792{
793 assert((lenv) && "lengh vector nil");
794 assert(((mlp).m_depth > 2) && "I see no hidden layer");
795 assert(lossderiv);
796 assert((actderiv) && "actderiv list");
797
798 (v_train).m_inc = (lenv)[(mlp).m_depth - 3];
799 (v_train).m_outc = (lenv)[(mlp).m_depth - 2];
800
801 __ae2f_AnnMlpPredictStream_imp(
802 (v_train), mlp, inp, out, lenv,
803 weight, bias, outstream, act
804 );
805
806 if((actderiv)[(mlp).m_depth - 2]) {
807 __ae2f_AnnSlpFetchDelta_imp(
808 (v_train), (v_train), (out), (out_desired)
809 , (actderiv)[(mlp).m_depth - 2]
810 , (lossderiv)
811 , (&((deltacache)[(mlp).m_outc * (((mlp).m_depth - 2) OPER_NONE)]))
812 );
813 } else {
814 __ae2f_AnnSlpFetchDelta_imp(
815 (v_train), (v_train), (out), (out_desired)
816 , /** actderiv */
817 , (lossderiv)
818 , (&((deltacache)[(mlp).m_outc * (((mlp).m_depth - 2) OPER_NONE)]))
819 );
820
821 }
822
823 __ae2f_AnnMlpFollowPrimal_imp(
824 OPER_NEG, OPER_NONE
825 , v_train, mlp, inp
826 , (&((deltacache)[(mlp).m_outc * (((mlp).m_depth - 2) OPER_NONE)]))
827 , lenv, outstream
828 , deltacache, weight, bias
829 , learningrate, learningrate_bias
830 , actderiv
831 ); \
832}
833
834#if ae2f_NEED_CLASS
835#define __ae2f_AnnMlpTrainPrimal(
836 /** tparam */
837 OPER_NEG,OPER_NONE,
838
839 /** param */
840 /* ,ae2f_err_t* const ae2f_opt */ reterr,
841 /* ae2f_AnnMlp* const */ mlp,
842 /* constae2f_float_t* const */ inp,
843 /* ae2f_float_t* const */ out,
844 /* constae2f_float_t* const */ out_desired \
845)\
846{
847 if((reterr) && *(reterr));
848 else unless((mlp) && (out) && (out_desired) && (inp)) {
849 assert(0 && "nullref");
850 (reterr) && (*(reterr) |= ae2f_errGlob_PTR_IS_NULL);
851 } else {
852 ae2f_AnnMlpTrain_t v_train;
853 __ae2f_AnnMlpTrainPrimal_imp(
854 OPER_NEG, OPER_NONE
855 , v_train, *(mlp), inp
856 , out, out_desired
857 , (mlp)->m_sz, (mlp)->m_outcache
858 , (mlp)->m_deltastream
859 , (mlp)->m_weight, (mlp)->m_bias
860 , (mlp)->m_learningrate, (mlp)->m_learningrate_bias
861 , (mlp)->m_act, (mlp)->m_actderiv, (mlp)->m_lossderiv
862 );
863 } \
864}
865
866#define __ae2f_AnnMlpTrainAutoPrimal(
867 /** tparam */
868 OPER_NEG,OPER_NONE,
869
870 /** param */
871 /* ,ae2f_err_t* const ae2f_opt */ reterr,
872 /* ae2f_AnnMlp* const */ mlp,
873 /* constae2f_float_t* const */ inp,
874 /* constae2f_float_t* const */ out_desired \
875)\
876{
877 if((reterr) && *(reterr));
878 else unless((mlp) && (out_desired) && (inp)) {
879 assert(0 && "nullref");
880 (reterr) && (*(reterr) |= ae2f_errGlob_PTR_IS_NULL);
881 } else {
882 ae2f_AnnMlpTrain_t v_train;
883 __ae2f_AnnMlpTrainPrimal_imp(
884 OPER_NEG, OPER_NONE
885 , v_train, *(mlp), inp
886 , &(mlp)->m_outcache[((mlp)->m_outc) * ((mlp)->m_depth - 2)]
887 , out_desired
888 , (mlp)->m_sz, (mlp)->m_outcache
889 , (mlp)->m_deltastream
890 , (mlp)->m_weight, (mlp)->m_bias
891 , (mlp)->m_learningrate, (mlp)->m_learningrate_bias
892 , (mlp)->m_act, (mlp)->m_actderiv, (mlp)->m_lossderiv
893 );
894 } \
895}
896
897#else
898#define __ae2f_AnnMlpTrainPrimal(...)
899 typedef char NO_ae2f_NEED_CLASS[-1]
900
901#define __ae2f_AnnMlpTrainAutoPrimal(...)
902 typedef char NO_ae2f_NEED_CLASS[-1]
903
904#endif
905
906
907#define __ae2f_AnnMlpTrain_C(reterr, mlp, inp, out, out_desired)
908 __ae2f_AnnMlpTrainPrimal(&1 ? 0 : 1, &1, reterr, mlp, inp, out, out_desired)
909
910#define __ae2f_AnnMlpTrainStream_C(reterr, mlp, inp, out, out_desired)
911 __ae2f_AnnMlpTrainPrimal(&1 ? 0 : 1, ae2f_NONE, reterr, mlp, inp, out, out_desired)
912
913#define __ae2f_AnnMlpTrain_imp(...)
914 __ae2f_AnnMlpTrainPrimal_imp(&1 ? 0 : 1, &1, __VA_ARGS__)
915
916#define __ae2f_AnnMlpTrainStream_imp(...)
919
920/** @see __ae2f_AnnMlpTrainAutoPrimal */
921#define __ae2f_AnnMlpTrainAuto_C(reterr, mlp, inp, out_desired)
922 __ae2f_AnnMlpTrainAutoPrimal(&1 ? 0 : 1, &1, reterr, mlp, inp, out_desired)
923
924/** @see __ae2f_AnnMlpTrainAutoPrimal */
925#define __ae2f_AnnMlpTrainAutoStream_C(reterr, mlp, inp, out_desired)
926 __ae2f_AnnMlpTrainAutoPrimal(-1, ae2f_NONE, reterr, mlp, inp, out_desired)
927
928#endif
929
930
931
932#undef __ae2f_MACRO_GENERATED
933
934#define __ae2f_MACRO_GENERATED 0
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_AnnUtilV2Name
#define ae2f_AnnUtilV2Name(A_t, B_t)
Definition Util.h:11
ae2f_AnnUtilV2
#define ae2f_AnnUtilV2(A_LEFT, A_t, A_POST, B_LEFT, B_t, B_POST)
Definition Util.h:14
ae2f_AnnUtilPtr2Name
#define ae2f_AnnUtilPtr2Name(A_t, B_t)
Definition Util.h:8
ON
#define ON
Definition cmake.hpp:5
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_WhenCXX
#define ae2f_WhenCXX(...)
Appears when the current language is C.
Definition Cxx.h:34
ae2f_NONE
#define ae2f_NONE
Literally nothing.
Definition Cxx.h:13
ae2f_float_t
ae2f_float ae2f_float_t
Definition Float.h:38
ae2f_LP
#define ae2f_LP(...)
Desired count required.
Definition Guide.h:23
ae2f_FREE
#define ae2f_FREE(...)
Use this marker to show the desired functions to effectively free the resources.
Definition Guide.h:33
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
ae2f_AnnMlpPredict
ae2f_SHAREDEXPORT void ae2f_AnnMlpPredict(ae2f_err_t *restrict reterr, const ae2f_AnnMlp *restrict const mlp, const ae2f_float_t *restrict const inp, ae2f_float_t *restrict const out) noexcept
Definition Mlp.imp.c:46
ae2f_AnnMlpFollowStream
ae2f_SHAREDEXPORT void ae2f_AnnMlpFollowStream(ae2f_err_t *const reterr, const ae2f_AnnMlp *mlp, const ae2f_float_t *const inp, const ae2f_float_t *const delta)
Definition Mlp.imp.c:76
ae2f_AnnMlpPredictStream
ae2f_SHAREDEXPORT void ae2f_AnnMlpPredictStream(ae2f_err_t *restrict reterr, const ae2f_AnnMlp *restrict const mlp, const ae2f_float_t *restrict const inp, ae2f_float_t *restrict const out) noexcept
Definition Mlp.imp.c:56
ae2f_AnnMlpTrainAutoStream
ae2f_SHAREDEXPORT void ae2f_AnnMlpTrainAutoStream(ae2f_err_t *restrict const ae2f_opt reterr, ae2f_AnnMlp *restrict const mlp, const ae2f_float_t *restrict const inp, const ae2f_float_t *restrict const out_desired) noexcept
Definition Mlp.imp.c:116
ae2f_AnnMlpTrainAuto
ae2f_SHAREDEXPORT void ae2f_AnnMlpTrainAuto(ae2f_err_t *restrict const ae2f_opt reterr, ae2f_AnnMlp *restrict const mlp, const ae2f_float_t *restrict const inp, const ae2f_float_t *restrict const out_desired) noexcept
Definition Mlp.imp.c:107
ae2f_AnnMlpDel
ae2f_SHAREDEXPORT void ae2f_AnnMlpDel(ae2f_AnnMlp *restrict const block) noexcept
Definition Mlp.imp.c:40
ae2f_AnnMlpMk
ae2f_SHAREDEXPORT void ae2f_AnnMlpMk(ae2f_err_t *restrict const reterr, ae2f_AnnMlp *restrict *restrict const retmk, const size_t depth, const size_t *restrict const szvector, ae2f_opt size_t *restrict const szswap_opt, ae2f_opt ae2f_AnnAct_t **restrict const act, ae2f_opt ae2f_AnnAct_t **restrict const actderiv, ae2f_AnnLoss_t *const lossderiv, ae2f_opt ae2f_float_t *restrict const deltastream, ae2f_opt ae2f_float_t *restrict const outcache, ae2f_opt ae2f_float_t *restrict const weight, ae2f_opt ae2f_float_t *restrict const bias, ae2f_float_t const learningrate, ae2f_float_t const learningrate_bias, const size_t offset, const size_t extra) noexcept
Definition Mlp.imp.c:5
ae2f_AnnMlpFollow
ae2f_SHAREDEXPORT void ae2f_AnnMlpFollow(ae2f_err_t *const reterr, const ae2f_AnnMlp *mlp, const ae2f_float_t *const inp, const ae2f_float_t *const delta)
Definition Mlp.imp.c:66
ae2f_AnnMlpTrainStream
ae2f_SHAREDEXPORT void ae2f_AnnMlpTrainStream(ae2f_err_t *restrict const ae2f_opt reterr, ae2f_AnnMlp *restrict const mlp, const ae2f_float_t *restrict const inp, ae2f_float_t *restrict const out, const ae2f_float_t *restrict const out_desired) noexcept
Definition Mlp.imp.c:97
ae2f_AnnMlpTrain
ae2f_SHAREDEXPORT void ae2f_AnnMlpTrain(ae2f_err_t *restrict const ae2f_opt reterr, ae2f_AnnMlp *restrict const mlp, const ae2f_float_t *restrict const inp, ae2f_float_t *restrict const out, const ae2f_float_t *restrict const out_desired) noexcept
Definition Mlp.imp.c:87
inp
const ae2f_AnnMlp_t const ae2f_float_t *const inp
Definition Mlp.def.cc:318
actderiv_then
size_t const ae2f_AnnSlp_t ae2f_float_t *const const ae2f_float_t *const ae2f_AnnAct_t actderiv_then
Definition Mlp.def.cc:508
mlp
const ae2f_AnnMlp_t mlp
Definition Mlp.def.cc:317
bias
const ae2f_AnnMlp_t const ae2f_float_t *const ae2f_float_t *const const size_t *const const ae2f_float_t *const const ae2f_float_t *const bias
Definition Mlp.def.cc:323
sz
const ae2f_AnnMlp_t const ae2f_float_t *const ae2f_float_t *const const size_t *const sz
Definition Mlp.def.cc:321
slp
const ae2f_AnnSlp_t slp
Definition Mlp.def.cc:484
outcache
const ae2f_AnnMlp_t const ae2f_float_t *const ae2f_float_t *const const size_t *const const ae2f_float_t *const const ae2f_float_t *const ae2f_float_t *const outcache
Definition Mlp.def.cc:325
delta
const ae2f_AnnSlp_t const ae2f_float_t *const const ae2f_float_t *const delta
Definition Mlp.def.cc:486
weight
const ae2f_AnnMlp_t const ae2f_float_t *const ae2f_float_t *const const size_t *const const ae2f_float_t *const weight
Definition Mlp.def.cc:322
iidx
const ae2f_AnnSlp_t const ae2f_float_t *const const ae2f_float_t *const const size_t iidx
Definition Mlp.def.cc:488
out
const ae2f_AnnMlp_t const ae2f_float_t *const ae2f_float_t *const out
Definition Mlp.def.cc:320
slp_then
size_t const ae2f_AnnSlp_t slp_then
Definition Mlp.def.cc:503
deltaseed
size_t const ae2f_AnnSlp_t ae2f_float_t *const const ae2f_float_t *const deltaseed
Definition Mlp.def.cc:506
OPER_NONE
#define OPER_NONE
Definition Mlp.def.cc:21
v_send
size_t v_send
Definition Mlp.def.cc:502
retdelta_then
size_t const ae2f_AnnSlp_t ae2f_float_t *const retdelta_then
Definition Mlp.def.cc:505
act_opt
const ae2f_AnnMlp_t const ae2f_float_t *const ae2f_float_t *const const size_t *const const ae2f_float_t *const const ae2f_float_t *const ae2f_float_t *const ae2f_AnnAct_t *const *const act_opt
Definition Mlp.def.cc:327
OPER_NEG
#define OPER_NEG
Definition Mlp.def.cc:20
ae2f_AnnSlpFit
ae2f_SHAREDEXPORT void ae2f_AnnSlpFit(ae2f_err_t *restrict const reterr_opt, const ae2f_AnnSlp *restrict const _this, ae2f_LP(_this::inc) const ae2f_float_t *restrict const prm_inp, ae2f_LP(_this::outc) const ae2f_float_t *restrict const prm_out, ae2f_LP(_this::outc) const ae2f_float_t *restrict const prm_out_desired) noexcept
Definition Slp.imp.c:82
ae2f_AnnSlpFetchDelta
ae2f_SHAREDEXPORT void ae2f_AnnSlpFetchDelta(ae2f_opt ae2f_err_t *restrict const err, const ae2f_AnnSlp *restrict slp, ae2f_LP(slp::outc) const ae2f_float_t *restrict const out, ae2f_LP(slp::outc) const ae2f_float_t *restrict const out_desired, ae2f_LP(slp::outc) ae2f_float_t *restrict const retdelta) noexcept
Definition Slp.imp.c:97
ae2f_AnnSlpTrain
ae2f_SHAREDEXPORT void ae2f_AnnSlpTrain(ae2f_err_t *restrict const err, ae2f_AnnSlp *restrict slp, ae2f_LP(slp::inc) const ae2f_float_t *restrict inp, ae2f_LP(slp::outc) const ae2f_float_t *restrict out_desired) noexcept
Definition Slp.imp.c:110
ae2f_AnnSlpPredict
ae2f_SHAREDEXPORT void ae2f_AnnSlpPredict(ae2f_err_t *restrict const err_opt, const ae2f_AnnSlp *restrict const _this, const ae2f_float_t *restrict const prm_in, ae2f_float_t *restrict const out) noexcept
Definition Slp.imp.c:59
ae2f_AnnSlpDel
ae2f_SHAREDEXPORT void ae2f_AnnSlpDel(ae2f_AnnSlp *restrict const slp) noexcept
Definition Slp.imp.c:55
ae2f_AnnSlpFollow
ae2f_SHAREDEXPORT void ae2f_AnnSlpFollow(ae2f_err_t *const restrict reterr_opt, const ae2f_AnnSlp *restrict const _this, const ae2f_float_t *restrict const prm_in, const ae2f_float_t *restrict const delta) noexcept
Definition Slp.imp.c:73
ae2f_AnnSlpMk
ae2f_SHAREDEXPORT void ae2f_AnnSlpMk(ae2f_LP(inc *outc) ae2f_float_t *restrict const weight_opt, ae2f_LP(outc) ae2f_float_t *restrict const bias_opt, ae2f_LP(outc) ae2f_float_t *restrict const cache_opt, const size_t inc, const size_t outc, const size_t offset_opt, const size_t extra_opt, ae2f_FREE(ae2f_AnnSlpDel, __ae2f_AnnSlpDel) ae2f_AnnSlp *restrict *restrict const slp, ae2f_opt ae2f_AnnAct_t *const act, ae2f_opt ae2f_AnnAct_t *const actderiv, ae2f_AnnLoss_t *const lossderiv, ae2f_float_t learningrate, ae2f_float_t learningrate_bias, ae2f_opt ae2f_err_t *restrict const err_opt) noexcept
Definition Slp.imp.c:26
ae2f_AnnSlpInit
ae2f_SHAREDEXPORT void ae2f_AnnSlpInit(ae2f_AnnSlp_t *restrict const _this, const size_t inc, const size_t outc, const size_t offset_opt, ae2f_err_t *restrict const err_opt, size_t *restrict const initsz_opt) noexcept __ae2f_AnnSlpInit_C(_this
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_AnnMlpFollowPrimal
#define __ae2f_AnnMlpFollowPrimal(...)
Definition Mlp.auto.h:756
__ae2f_AnnMlpHidDeltaSingle_imp
#define __ae2f_AnnMlpHidDeltaSingle_imp(v_single, slp, weight, delta, iidx)
Definition Mlp.auto.h:503
__ae2f_MACRO_GENERATED
#define __ae2f_MACRO_GENERATED
Definition Mlp.auto.h:2
__ae2f_AnnMlpTrainAutoPrimal
#define __ae2f_AnnMlpTrainAutoPrimal(...)
Definition Mlp.auto.h:897
__ae2f_AnnMlpPropagate_imp
#define __ae2f_AnnMlpPropagate_imp(v_tmp, v_send, slp_then, retdelta_then, deltaseed, actderiv_then, inp)
delta to delta
Definition Mlp.auto.h:525
__ae2f_AnnMlpPredictStream_imp
#define __ae2f_AnnMlpPredictStream_imp(...)
Definition Mlp.auto.h:491
__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:552
__ae2f_AnnMlpPredictPrimal
#define __ae2f_AnnMlpPredictPrimal(...)
Definition Mlp.auto.h:485
__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:330
__ae2f_AnnMlpInitWithOutSz_imp
#define __ae2f_AnnMlpInitWithOutSz_imp(...)
Definition Mlp.auto.h:321
__ae2f_AnnMlpTrainPrimal
#define __ae2f_AnnMlpTrainPrimal(...)
Definition Mlp.auto.h:894
__ae2f_AnnMlpSz_imp
#define __ae2f_AnnMlpSz_imp(...)
Definition Mlp.auto.h:318
__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:767
__ae2f_AnnMlpMk_imp
#define __ae2f_AnnMlpMk_imp(...)
Definition Mlp.auto.h:315
__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