mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2025-09-10 04:23:24 -04:00
1380 lines
33 KiB
NASM
1380 lines
33 KiB
NASM
;MIT License
|
|
|
|
;Copyright (c) 2020 Artem Yashin
|
|
|
|
;Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
;of this software and associated documentation files (the "Software"), to deal
|
|
;in the Software without restriction, including without limitation the rights
|
|
;to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
;copies of the Software, and to permit persons to whom the Software is
|
|
;furnished to do so, subject to the following conditions:
|
|
|
|
;The above copyright notice and this permission notice shall be included in all
|
|
;copies or substantial portions of the Software.
|
|
|
|
;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
;SOFTWARE.
|
|
|
|
;https://www.youtube.com/watch?v=GNcGPw_Kb_0
|
|
|
|
;https://www.youtube.com/watch?v=wzIOl4hWP3U
|
|
; 1:20 - cats images
|
|
|
|
format MS COFF
|
|
public EXPORTS
|
|
section '.flat' code readable align 16
|
|
|
|
include "..\..\..\KOSfuncs.inc"
|
|
include "..\..\..\proc32.inc"
|
|
include "..\..\..\macros.inc"
|
|
include "..\..\..\bcc32\include\kos_func.inc"
|
|
include "..\..\..\bcc32\include\kos_heap.inc"
|
|
|
|
@@memcpy$qpvpxvui equ @memcpy$qpvpxvui
|
|
@@DoubleToStr$qduso equ @DoubleToStr$qduso
|
|
@@strlen$qpxc equ @strlen$qpxc
|
|
@@strstr$qpxct1 equ @strstr$qpxct1
|
|
@@strchr$qpxci equ @strchr$qpxci
|
|
@@StrToInt$qpc equ @StrToInt$qpc
|
|
@@StrToDouble$qpc equ @StrToDouble$qpc
|
|
|
|
mem.alloc dd ? ;memory allocation function
|
|
mem.free dd ? ;function to free up memory
|
|
mem.realloc dd ? ;function for memory reallocation
|
|
dll.load dd ?
|
|
|
|
PRECISION equ 16
|
|
NNP_FF_BIN equ 0x6e6962
|
|
NNP_FF_JSON equ 0x6e6f736a
|
|
|
|
struct Layer
|
|
c_size dd ? ;+ 0 curent size - number of neurons in the current layer
|
|
n_size dd ? ;+ 4 next size - number of neurons in the next layer
|
|
neurons dd ? ;+ 8 []
|
|
biases dd ? ;+12 []
|
|
weights dd ? ;+16 [][]
|
|
ends
|
|
|
|
struct NeuralNetwork
|
|
learningRate dq ? ;+ 0
|
|
layers dd ? ;+ 8 []
|
|
layers_length dd ? ;+12 number of layers
|
|
activation dd ? ;+16 pointer to activation function
|
|
derivative dd ? ;+20 function pointer
|
|
errors dd ? ;+24 array for calculations
|
|
errorsNext dd ? ;+28
|
|
gradients dd ? ;+32
|
|
deltas dd ? ;+36
|
|
ends
|
|
|
|
align 4
|
|
_rand_x dd 0
|
|
|
|
txt_QlearningRateQ_ db '"learningRate": ',0
|
|
txt_zap_nl db ",",10,0
|
|
txt_Qlayers_lengthQ db '"layers_length": ',0
|
|
txt_QlayersQ db '"layers": [',0
|
|
txt_nl_t_Qc_sizeQ db 10,9,'{"c_size": ',0
|
|
txt_zap_nl_t_Qn_sizeQ db ",",10,9,'"n_size": ',0
|
|
txt_t_QneuronsQ db 9,'"neurons": [',0
|
|
txt_zap_sp db ", ",0
|
|
txt_sqbr_zap_nl db "],",10,0
|
|
txt_t_QbiasesQ db 9,'"biases": [',0
|
|
txt_sqbr_zap_t_QweightsQ db "],",10,9,'"weights": [',10,9,9,0
|
|
txt_zap_nl_t_t db ",",10,9,9,0
|
|
txt_sqbro db "[",0
|
|
txt_sqbr db "]",0
|
|
txt_sqbr_fbr_zap db "]},",0
|
|
txt_nl_t_sqbr db 10,9,"]",0
|
|
txt_learningRate db '"learningRate"',0
|
|
txt_layers_length db '"layers_length"',0
|
|
;txt_pri_zap db '%i,',0
|
|
txt_c_size db '"c_size"',0
|
|
txt_n_size db '"n_size"',0
|
|
txt_biases db '"biases"',0
|
|
txt_weights db '"weights"',0
|
|
|
|
txt_err_layers_neq db 'number of layers does not match',0
|
|
txt_err_c_size db "not found value 'c_size'",0
|
|
txt_err_sqbrl_b1 db "not found opening '[' for biases",0
|
|
txt_err_sqbrl_w1 db "not found opening '[' for weights",0
|
|
txt_err_sqbrl_w2 db "not found opening '[[' for weights",0
|
|
txt_err_sqbrr_w2 db "not found closing ']]' for weights",0
|
|
|
|
align 16
|
|
proc lib_init
|
|
mov [mem.alloc], eax
|
|
mov [mem.free], ebx
|
|
mov [mem.realloc], ecx
|
|
mov [dll.load], edx
|
|
ret
|
|
endp
|
|
|
|
align 16
|
|
Math_random:
|
|
imul eax,dword[_rand_x],22695477
|
|
inc eax
|
|
push ecx
|
|
mov dword[_rand_x],eax
|
|
and eax,65535
|
|
mov dword[esp],eax
|
|
fild dword[esp]
|
|
fmul dword[@f]
|
|
pop edx
|
|
ret
|
|
align 4
|
|
@@:
|
|
db 0,0,128,55 ;dd 1.0/65536.0
|
|
|
|
align 16
|
|
ieee754_exp:
|
|
fld qword[esp+4]
|
|
fldl2e ;push log2(e) onto stack
|
|
fmulp
|
|
fst st1 ;copies st0 to st1
|
|
frndint ;round to integer
|
|
fst st2 ;copies st0 to st2
|
|
fsubp ;subtraction with stack pop
|
|
f2xm1 ;raises 2 to the power st0 and subtracts 1
|
|
fld1
|
|
faddp
|
|
fscale ;scale by powers of two
|
|
ret
|
|
|
|
align 16
|
|
sigmoid:
|
|
push ebp
|
|
mov ebp,esp
|
|
add esp,-8
|
|
fld qword[ebp+8]
|
|
fchs
|
|
fstp qword[esp]
|
|
call ieee754_exp
|
|
add esp,8
|
|
fadd dword[f_1_0]
|
|
fdivr dword[f_1_0]
|
|
pop ebp
|
|
ret 8
|
|
|
|
align 16
|
|
dsigmoid:
|
|
push ebp
|
|
mov ebp,esp
|
|
fld1
|
|
fsub qword[ebp+8]
|
|
fmul qword[ebp+8]
|
|
pop ebp
|
|
ret 8
|
|
|
|
align 16
|
|
Layer_Create:
|
|
push ebp
|
|
mov ebp,esp
|
|
push ebx esi edi
|
|
mov esi,[ebp+8]
|
|
mov edi,[ebp+12]
|
|
mov ebx,edi
|
|
shl ebx,3
|
|
mov dword[esi+Layer.c_size],edi
|
|
mov eax,[ebp+16]
|
|
mov dword[esi+Layer.n_size],eax
|
|
push ebx
|
|
call @$bnwa$qui
|
|
pop ecx
|
|
mov dword[esi+Layer.neurons],eax
|
|
push ebx
|
|
call @$bnwa$qui
|
|
pop ecx
|
|
mov dword[esi+Layer.biases],eax
|
|
mov eax,edi
|
|
shl eax,2
|
|
push eax
|
|
call @$bnwa$qui
|
|
pop ecx
|
|
mov dword[esi+Layer.weights],eax
|
|
xor ebx,ebx
|
|
cmp edi,ebx
|
|
jbe .end_f
|
|
@@:
|
|
mov eax,[ebp+16]
|
|
shl eax,3
|
|
push eax
|
|
call @$bnwa$qui
|
|
pop ecx
|
|
mov edx,[esi+Layer.weights]
|
|
mov dword[edx+4*ebx],eax
|
|
inc ebx
|
|
cmp edi,ebx
|
|
ja @b
|
|
.end_f:
|
|
pop edi esi ebx ebp
|
|
ret 12
|
|
|
|
;+ 8 NeuralNetwork* o
|
|
;+12 double learningRate
|
|
;+20 void* activation
|
|
;+24 void* derivative
|
|
;+28 unsigned long* sizes
|
|
;+32 long sizes_length
|
|
align 16
|
|
NNP_Create:
|
|
push ebp
|
|
mov ebp,esp
|
|
add esp,-12
|
|
push ebx esi edi
|
|
mov eax,[ebp+8] ;o
|
|
mov edx,[ebp+12] ;learningRate
|
|
mov dword[eax+NeuralNetwork.learningRate],edx
|
|
mov edx,[ebp+16] ;learningRate (2)
|
|
mov dword[eax+NeuralNetwork.learningRate+4],edx
|
|
mov ecx,[ebp+8] ;o
|
|
mov eax,[ebp+20] ;activation
|
|
or eax,eax
|
|
jnz @f
|
|
mov eax,sigmoid
|
|
@@:
|
|
mov dword[ecx+NeuralNetwork.activation],eax
|
|
mov edx,[ebp+8] ;o
|
|
mov eax,[ebp+24] ;derivative
|
|
or eax,eax
|
|
jnz @f
|
|
mov eax,dsigmoid
|
|
@@:
|
|
mov dword[edx+NeuralNetwork.derivative],eax
|
|
mov eax,[ebp+32] ;sizes_length
|
|
imul eax,sizeof.Layer
|
|
stdcall @$bnwa$qui,eax
|
|
pop ecx
|
|
mov edx,[ebp+8] ;o
|
|
mov dword[edx+NeuralNetwork.layers],eax
|
|
mov ecx,[ebp+8] ;o
|
|
mov eax,[ebp+32] ;sizes_length
|
|
mov dword[ecx+NeuralNetwork.layers_length],eax
|
|
xor edi,edi ;i=0
|
|
mov eax,[ebp+28] ;sizes
|
|
lea edx,[eax+4]
|
|
mov dword[ebp-8],edx ;save &sizes[i+1]
|
|
jmp .3
|
|
.cycle_0: ;for (i=0; i < sizes_length; i++)
|
|
xor ecx,ecx
|
|
mov dword[ebp-4],ecx ;nextSize = 0
|
|
mov eax,[ebp+32] ;sizes_length
|
|
dec eax
|
|
cmp edi,eax
|
|
jae @f
|
|
mov edx,[ebp-8]
|
|
mov ecx,[edx]
|
|
mov dword[ebp-4],ecx ;nextSize = sizes[i+1]
|
|
@@:
|
|
mov eax,[ebp-4]
|
|
push eax
|
|
mov edx,[ebp-8]
|
|
mov ecx,[edx-4]
|
|
push ecx
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
mov eax,[ebp+8] ;o
|
|
mov edx,[eax+NeuralNetwork.layers]
|
|
add edx,ecx
|
|
stdcall Layer_Create,edx
|
|
xor esi,esi ;j=0
|
|
mov eax,[ebp-8]
|
|
lea edx,[eax-4]
|
|
mov dword[ebp-12],edx ;save &sizes[i]
|
|
jmp .2
|
|
.cycle_1: ;for (j=0; j < sizes[i]; j++)
|
|
call Math_random
|
|
fmul dword[f_2_0]
|
|
fsub dword[f_1_0]
|
|
mov eax,[ebp+8] ;o
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
add ecx,[eax+NeuralNetwork.layers]
|
|
mov ecx,[ecx+Layer.biases]
|
|
fstp qword[ecx+8*esi]
|
|
xor ebx,ebx ;k=0
|
|
cmp ebx,[ebp-4]
|
|
jae .1
|
|
@@: ;for (k=0; k < nextSize; k++)
|
|
call Math_random
|
|
fmul dword[f_2_0]
|
|
fsub dword[f_1_0]
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8] ;o
|
|
mov ecx,[edx+NeuralNetwork.layers]
|
|
mov eax,[ecx+eax+Layer.weights]
|
|
mov edx,[eax+4*esi]
|
|
fstp qword[edx+8*ebx]
|
|
inc ebx
|
|
cmp ebx,[ebp-4]
|
|
jb @b
|
|
.1:
|
|
inc esi
|
|
.2:
|
|
mov ecx,[ebp-12]
|
|
cmp esi,[ecx]
|
|
jb .cycle_1
|
|
inc edi
|
|
add dword[ebp-8],4
|
|
.3:
|
|
cmp edi,[ebp+32] ;sizes_length
|
|
jb .cycle_0
|
|
;create errors array
|
|
push dword[ebp+8]
|
|
call NNP_GetMaxLLen
|
|
mov esi,eax
|
|
shl esi,4
|
|
stdcall @$bnwa$qui,esi
|
|
pop ecx
|
|
mov edx,[ebp+8]
|
|
mov dword[edx+NeuralNetwork.errors],eax
|
|
shr esi,1
|
|
add eax,esi
|
|
mov dword[edx+NeuralNetwork.errorsNext],eax
|
|
;create gradients array
|
|
stdcall @$bnwa$qui,esi
|
|
pop ecx
|
|
mov edx,[ebp+8]
|
|
mov dword[edx+NeuralNetwork.gradients],eax
|
|
;create deltas array
|
|
shr esi,1
|
|
stdcall @$bnwa$qui,esi
|
|
pop ecx
|
|
mov edx,[ebp+8]
|
|
mov dword[edx+NeuralNetwork.deltas],eax
|
|
pop edi esi ebx
|
|
mov esp,ebp
|
|
pop ebp
|
|
ret 28
|
|
align 4
|
|
f_2_0:
|
|
dd 2.0
|
|
f_1_0:
|
|
dd 1.0
|
|
|
|
;random number filling
|
|
;+ 8 NeuralNetwork* o
|
|
align 16
|
|
NNP_Reset:
|
|
push ebp
|
|
mov ebp,esp
|
|
add esp,-8
|
|
push ebx esi edi
|
|
|
|
xor edi,edi ;i=0
|
|
jmp .3
|
|
.cycle_0: ;for (i=0; i < o->layers_length; i++)
|
|
xor esi,esi ;j=0
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8]
|
|
add eax,[edx+NeuralNetwork.layers]
|
|
mov edx,[eax+Layer.n_size]
|
|
mov [ebp-4],edx
|
|
mov edx,[eax+Layer.c_size]
|
|
mov [ebp-8],edx
|
|
jmp .2
|
|
.cycle_1: ;for (j=0; j < o->layers[i].c_size; j++)
|
|
call Math_random
|
|
fmul dword[f_2_0]
|
|
fsub dword[f_1_0]
|
|
mov eax,[ebp+8] ;o
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
add ecx,[eax+NeuralNetwork.layers]
|
|
mov ecx,[ecx+Layer.biases]
|
|
fstp qword[ecx+8*esi]
|
|
xor ebx,ebx ;k=0
|
|
cmp ebx,[ebp-4]
|
|
jae .1
|
|
@@: ;for (k=0; k < o->layers[i].n_size; k++)
|
|
call Math_random
|
|
fmul dword[f_2_0]
|
|
fsub dword[f_1_0]
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8] ;o
|
|
add eax,[edx+NeuralNetwork.layers]
|
|
mov eax,[eax+Layer.weights]
|
|
mov edx,[eax+4*esi] ;edx = &o->layers[i].weights[j]
|
|
fstp qword[edx+8*ebx] ;o->layers[i].weights[j][k] = Math_random()*2.0-1.0;
|
|
inc ebx ;k++
|
|
cmp ebx,[ebp-4]
|
|
jb @b
|
|
.1:
|
|
inc esi ;j++
|
|
.2:
|
|
cmp esi,[ebp-8]
|
|
jb .cycle_1
|
|
inc edi ;i++
|
|
.3:
|
|
mov ecx,[ebp+8] ;o
|
|
cmp edi,[ecx+NeuralNetwork.layers_length]
|
|
jb .cycle_0
|
|
pop edi esi ebx
|
|
mov esp,ebp
|
|
pop ebp
|
|
ret 4
|
|
|
|
;calculation of input and output neurons
|
|
;+ 8 NeuralNetwork* o
|
|
;+12 double* inputs
|
|
align 16
|
|
NNP_FeedForward:
|
|
push ebp
|
|
mov ebp,esp
|
|
add esp,-4
|
|
push ebx esi edi
|
|
mov eax,[ebp+8]
|
|
mov eax,[eax+NeuralNetwork.layers]
|
|
mov ecx,[eax+Layer.c_size]
|
|
shl ecx,1
|
|
mov edi,[eax+Layer.neurons]
|
|
mov esi,[ebp+12]
|
|
rep movsd
|
|
mov edi,[ebp+8]
|
|
mov esi,[edi+NeuralNetwork.layers]
|
|
sub esi,sizeof.Layer
|
|
mov dword[ebp-4],1 ;i = 1
|
|
jmp .3
|
|
align 4
|
|
.cycle_0:
|
|
add esi,sizeof.Layer
|
|
xor ebx,ebx ;j=0
|
|
jmp .2
|
|
align 4
|
|
.cycle_1:
|
|
mov edx,[esi+sizeof.Layer+Layer.neurons]
|
|
xor eax,eax
|
|
mov dword[edx+8*ebx],eax
|
|
mov dword[edx+8*ebx+4],eax ;l1.neurons[j] = 0
|
|
;;xor eax,eax ;k=0
|
|
jmp .1
|
|
align 4
|
|
.cycle_2:
|
|
;l1.neurons[j] += l.neurons[k] * l.weights[k][j]
|
|
mov ecx,[esi+Layer.neurons] ;l.neurons
|
|
fld qword[ecx+8*eax] ;st0 = l.neurons[k]
|
|
mov ecx,[esi+Layer.weights]
|
|
mov ecx,[ecx+4*eax]
|
|
fmul qword[ecx+8*ebx] ;st0 *= l.weights[k][j]
|
|
fadd qword[edx+8*ebx] ;st0 += l1.neurons[j]
|
|
fstp qword[edx+8*ebx]
|
|
inc eax ;k++
|
|
.1:
|
|
cmp eax,[esi+Layer.c_size] ;k < l.c_size
|
|
jb .cycle_2
|
|
mov eax,[esi+sizeof.Layer+Layer.biases]
|
|
fld qword[eax+8*ebx]
|
|
fadd qword[edx+8*ebx]
|
|
sub esp,8
|
|
fstp qword[esp] ;push l1.neurons[j]
|
|
call dword[edi+NeuralNetwork.activation]
|
|
fstp qword[edx+8*ebx]
|
|
inc ebx ;j++
|
|
.2:
|
|
cmp ebx,[esi+sizeof.Layer+Layer.c_size] ;j < l1.c_size
|
|
jb .cycle_1
|
|
inc dword[ebp-4] ;i++
|
|
.3:
|
|
mov eax,[edi+NeuralNetwork.layers_length]
|
|
cmp eax,[ebp-4]
|
|
ja .cycle_0
|
|
mov eax,[esi+sizeof.Layer+Layer.neurons]
|
|
pop edi esi ebx
|
|
mov esp,ebp
|
|
pop ebp
|
|
ret 8
|
|
|
|
;+ 8 NeuralNetwork* o
|
|
;+12 double* targets
|
|
align 16
|
|
NNP_BackPropagation:
|
|
;cycle_0 for (i = 0; i < l.c_size; i++)
|
|
;cycle_1 for (; k >= 0; k--)
|
|
;cycle_2 for (i = 0; i < l1.c_size; i++)
|
|
;cycle_3 for (i = 0; i < l1.c_size; i++)
|
|
;cycle_4 for (j = 0; j < l.c_size; j++)
|
|
;cycle_5 for (i = 0; i < l.c_size; i++)
|
|
;cycle_6 for (j = 0; j < l1.c_size; j++)
|
|
;cycle_7 for (i = 0; i < l1.c_size; i++)
|
|
;cycle_8 for (j = 0; j < l.c_size; j++)
|
|
push ebp
|
|
mov ebp,esp
|
|
add esp,-12
|
|
push ebx esi edi
|
|
mov esi,[ebp+8]
|
|
mov edi,[esi+NeuralNetwork.layers_length]
|
|
dec edi
|
|
mov dword[ebp-4],edi ;k = o->layers_length - 1
|
|
imul edi,sizeof.Layer
|
|
add edi,[esi+NeuralNetwork.layers]
|
|
xor ebx,ebx ;i=0
|
|
mov eax,[ebp+12] ;eax = targets[]
|
|
jmp .1
|
|
align 4
|
|
.cycle_0:
|
|
mov edx,[edi+Layer.neurons]
|
|
mov ecx,[esi+NeuralNetwork.errors]
|
|
fld qword[eax]
|
|
fsub qword[edx+8*ebx]
|
|
fstp qword[ecx+8*ebx]
|
|
inc ebx
|
|
add eax,8
|
|
.1:
|
|
cmp ebx,[edi+Layer.c_size]
|
|
jb .cycle_0
|
|
dec dword[ebp-4] ;k--
|
|
cmp dword[ebp-4],0
|
|
jl .end_f
|
|
align 4
|
|
.cycle_1:
|
|
sub edi,sizeof.Layer
|
|
xor ebx,ebx ;i=0
|
|
jmp .2
|
|
align 4
|
|
.cycle_2:
|
|
mov eax,[edi+sizeof.Layer+Layer.neurons]
|
|
push dword[eax+8*ebx+4]
|
|
push dword[eax+8*ebx]
|
|
call dword[esi+NeuralNetwork.derivative]
|
|
mov ecx,[esi+NeuralNetwork.errors]
|
|
fmul qword[ecx+8*ebx]
|
|
fmul qword[esi+NeuralNetwork.learningRate]
|
|
mov edx,[esi+NeuralNetwork.gradients]
|
|
fstp qword[edx+8*ebx]
|
|
inc ebx
|
|
.2:
|
|
cmp ebx,[edi+sizeof.Layer+Layer.c_size]
|
|
jb .cycle_2
|
|
mov edx,[esi+NeuralNetwork.deltas]
|
|
xor ebx,ebx
|
|
jmp .3
|
|
align 4
|
|
.cycle_3:
|
|
mov eax,[edi+Layer.c_size]
|
|
shl eax,3
|
|
push eax
|
|
call @$bnwa$qui
|
|
pop ecx
|
|
mov dword[edx],eax
|
|
xor eax,eax ;j=0
|
|
jmp @f
|
|
align 4
|
|
.cycle_4:
|
|
mov ecx,[esi+NeuralNetwork.gradients]
|
|
fld qword[ecx+8*ebx]
|
|
mov ecx,[edi+Layer.neurons]
|
|
fmul qword[ecx+8*eax]
|
|
mov ecx,[edx]
|
|
fstp qword[ecx+8*eax]
|
|
inc eax
|
|
@@:
|
|
cmp eax,[edi+Layer.c_size]
|
|
jb .cycle_4
|
|
inc ebx
|
|
add edx,4
|
|
.3:
|
|
cmp ebx,[edi+sizeof.Layer+Layer.c_size]
|
|
jb .cycle_3
|
|
xor ebx,ebx
|
|
jmp .4
|
|
align 4
|
|
.cycle_5:
|
|
mov eax,[esi+NeuralNetwork.errorsNext]
|
|
xor edx,edx
|
|
mov dword[eax+8*ebx],edx
|
|
mov dword[eax+8*ebx+4],edx
|
|
xor eax,eax ;j=0
|
|
jmp @f
|
|
align 4
|
|
.cycle_6:
|
|
mov edx,[edi+Layer.weights]
|
|
mov ecx,[edx+4*ebx]
|
|
mov edx,[esi+NeuralNetwork.errors]
|
|
fld qword[ecx+8*eax]
|
|
fmul qword[edx+8*eax]
|
|
mov ecx,[esi+NeuralNetwork.errorsNext]
|
|
fadd qword[ecx+8*ebx]
|
|
fstp qword[ecx+8*ebx]
|
|
inc eax
|
|
@@:
|
|
cmp eax,[edi+sizeof.Layer+Layer.c_size]
|
|
jb .cycle_6
|
|
inc ebx
|
|
.4:
|
|
cmp ebx,[edi]
|
|
jb .cycle_5
|
|
;copy errors to next level
|
|
mov eax,[esi+NeuralNetwork.errors]
|
|
mov edx,[esi+NeuralNetwork.errorsNext]
|
|
mov dword[esi+NeuralNetwork.errors],edx
|
|
mov dword[esi+NeuralNetwork.errorsNext],eax
|
|
mov eax,[esi+NeuralNetwork.deltas]
|
|
mov dword[ebp-12],eax
|
|
xor ebx,ebx ;i=0
|
|
jmp .6
|
|
align 4
|
|
.cycle_7:
|
|
mov ecx,[esi+NeuralNetwork.gradients]
|
|
mov eax,[edi+sizeof.Layer+Layer.biases]
|
|
fld qword[ecx+8*ebx]
|
|
fadd qword[eax+8*ebx]
|
|
fstp qword[eax+8*ebx]
|
|
xor eax,eax ;j=0
|
|
mov edx,[ebp-12] ;edx = deltas[i]
|
|
jmp .5
|
|
align 4
|
|
.cycle_8:
|
|
; mov ecx,[edx]
|
|
; mov ecx,[ecx+8*eax+4]
|
|
; and ecx,0x7ff80000
|
|
; cmp ecx,0x7ff80000
|
|
; jne @f
|
|
; push ebx
|
|
; mov ecx,[edx]
|
|
; xor ebx,ebx
|
|
; mov dword[ecx+8*eax],ebx
|
|
; mov dword[ecx+8*eax+4],ebx
|
|
; pop ebx
|
|
;@@:
|
|
mov ecx,[edx]
|
|
fld qword[ecx+8*eax]
|
|
mov ecx,[edi+Layer.weights]
|
|
mov ecx,[ecx+4*eax]
|
|
fadd qword[ecx+8*ebx]
|
|
fstp qword[ecx+8*ebx]
|
|
; mov ecx,[edi+Layer.weights]
|
|
; mov ecx,[ecx+4*eax]
|
|
; mov ecx,[ecx+8*ebx+4]
|
|
; and ecx,0x7ff80000
|
|
; cmp ecx,0x7ff80000
|
|
; jne @f
|
|
; mov ecx,[edi+Layer.weights]
|
|
; mov ecx,[ecx+4*eax]
|
|
; push edx
|
|
; xor edx,edx
|
|
; mov dword[ecx+8*ebx],edx
|
|
; mov dword[ecx+8*ebx+4],edx
|
|
; pop edx
|
|
;@@:
|
|
inc eax
|
|
.5:
|
|
cmp eax,[edi+Layer.c_size]
|
|
jb .cycle_8
|
|
mov eax,[ebp-12]
|
|
stdcall @$bdele$qpv, [eax]
|
|
pop ecx
|
|
inc ebx
|
|
add dword[ebp-12],4
|
|
.6:
|
|
cmp ebx,[edi+sizeof.Layer+Layer.c_size]
|
|
jb .cycle_7
|
|
dec dword[ebp-4]
|
|
cmp dword[ebp-4],0
|
|
jge .cycle_1
|
|
.end_f:
|
|
pop edi esi ebx
|
|
mov esp,ebp
|
|
pop ebp
|
|
ret 8
|
|
|
|
|
|
;NNP_GetMemSize:
|
|
; todo
|
|
|
|
;+ 8 NeuralNetwork* o
|
|
;+12 unsigned long fmt
|
|
;+16 char* m_data
|
|
align 16
|
|
NNP_GetMemData:
|
|
push ebp
|
|
mov ebp,esp
|
|
add esp,-12
|
|
push ebx esi edi
|
|
cmp dword[ebp+12],NNP_FF_JSON
|
|
jne .end_f
|
|
mov esi,[ebp+16]
|
|
mov byte[esi],0
|
|
stdcall str_cat, esi,txt_QlearningRateQ_
|
|
push 1
|
|
push PRECISION
|
|
mov eax,[ebp+8]
|
|
push dword[eax+NeuralNetwork.learningRate+4]
|
|
push dword[eax+NeuralNetwork.learningRate]
|
|
call @@DoubleToStr$qduso
|
|
add esp,16
|
|
stdcall str_cat, esi,eax
|
|
stdcall str_cat, esi,txt_zap_nl
|
|
stdcall str_cat, esi,txt_Qlayers_lengthQ
|
|
push 1
|
|
push 0
|
|
mov ecx,[ebp+8]
|
|
fild dword[ecx+NeuralNetwork.layers_length]
|
|
add esp,-8
|
|
fstp qword[esp]
|
|
call @@DoubleToStr$qduso
|
|
add esp,16
|
|
stdcall str_cat, esi,eax
|
|
stdcall str_cat, esi,txt_zap_nl
|
|
stdcall str_cat, esi,txt_QlayersQ
|
|
xor edi,edi ;i=0
|
|
jmp .7
|
|
align 4
|
|
.cycle_0:
|
|
push esi
|
|
call @@strlen$qpxc
|
|
pop ecx
|
|
add esi,eax
|
|
stdcall str_cat, esi,txt_nl_t_Qc_sizeQ
|
|
mov ebx,edi
|
|
imul ebx,sizeof.Layer
|
|
push 1
|
|
push 0
|
|
mov edx,[ebp+8]
|
|
mov edx,[edx+NeuralNetwork.layers]
|
|
xor eax,eax
|
|
add esp,-8
|
|
mov ecx,[edx+ebx+Layer.c_size]
|
|
mov dword[ebp-12],ecx
|
|
mov dword[ebp-8],eax
|
|
fild qword[ebp-12]
|
|
fstp qword[esp]
|
|
call @@DoubleToStr$qduso
|
|
add esp,16
|
|
stdcall str_cat, esi,eax
|
|
stdcall str_cat, esi,txt_zap_nl_t_Qn_sizeQ
|
|
push 1
|
|
push 0
|
|
mov ecx,[ebp+8]
|
|
mov ecx,[ecx+NeuralNetwork.layers]
|
|
xor edx,edx
|
|
add esp,-8
|
|
mov eax,[ecx+ebx+Layer.n_size]
|
|
mov dword[ebp-12],eax
|
|
mov dword[ebp-8],edx
|
|
fild qword[ebp-12]
|
|
fstp qword[esp]
|
|
call @@DoubleToStr$qduso
|
|
add esp,16
|
|
stdcall str_cat, esi,eax
|
|
stdcall str_cat, esi,txt_zap_nl
|
|
stdcall str_cat, esi,txt_t_QneuronsQ
|
|
xor ebx,ebx ;j=0
|
|
jmp .1
|
|
align 4
|
|
.cycle_1:
|
|
test ebx,ebx
|
|
je @f
|
|
stdcall str_cat, esi,txt_zap_sp
|
|
@@:
|
|
push 1
|
|
push PRECISION
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8]
|
|
mov ecx,[edx+NeuralNetwork.layers]
|
|
mov eax,[ecx+eax+Layer.neurons]
|
|
push dword[eax+8*ebx+4]
|
|
push dword[eax+8*ebx]
|
|
call @@DoubleToStr$qduso
|
|
add esp,16
|
|
stdcall str_cat, esi,eax
|
|
inc ebx
|
|
.1:
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
mov eax,[ebp+8]
|
|
add ecx,[eax+NeuralNetwork.layers]
|
|
cmp ebx,[ecx+Layer.c_size]
|
|
jb .cycle_1
|
|
stdcall str_cat, esi,txt_sqbr_zap_nl
|
|
stdcall str_cat, esi,txt_t_QbiasesQ
|
|
xor ebx,ebx ;j=0
|
|
jmp .2
|
|
align 4
|
|
.cycle_2:
|
|
test ebx,ebx
|
|
je @f
|
|
stdcall str_cat, esi,txt_zap_sp
|
|
@@:
|
|
push 1
|
|
push PRECISION
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8]
|
|
add eax,[edx+NeuralNetwork.layers]
|
|
mov eax,[eax+Layer.biases]
|
|
push dword[eax+8*ebx+4]
|
|
push dword[eax+8*ebx]
|
|
call @@DoubleToStr$qduso
|
|
add esp,16
|
|
stdcall str_cat, esi,eax
|
|
inc ebx
|
|
.2:
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
mov eax,[ebp+8]
|
|
add ecx,[eax+NeuralNetwork.layers]
|
|
cmp ebx,[ecx+Layer.c_size]
|
|
jb .cycle_2
|
|
stdcall str_cat, esi,txt_sqbr_zap_t_QweightsQ
|
|
mov eax,[ebp+8]
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
add ecx,[eax+NeuralNetwork.layers]
|
|
cmp dword[ecx+Layer.n_size],0
|
|
je .6
|
|
xor ebx,ebx
|
|
jmp .5
|
|
.cycle_3:
|
|
test ebx,ebx
|
|
je @f
|
|
stdcall str_cat, esi,txt_zap_nl_t_t
|
|
@@:
|
|
stdcall str_cat, esi,txt_sqbro
|
|
xor eax,eax
|
|
mov dword[ebp-4],eax
|
|
jmp .4
|
|
.3:
|
|
cmp dword[ebp-4],0
|
|
je @f
|
|
stdcall str_cat, esi,txt_zap_sp
|
|
@@:
|
|
push 1
|
|
push PRECISION
|
|
mov edx,edi
|
|
imul edx,sizeof.Layer
|
|
mov eax,[ebp+8]
|
|
add edx,[eax+NeuralNetwork.layers]
|
|
mov edx,[edx+Layer.weights]
|
|
mov ecx,[edx+4*ebx]
|
|
mov eax,[ebp-4]
|
|
push dword[ecx+8*eax+4]
|
|
push dword[ecx+8*eax]
|
|
@@:
|
|
call @@DoubleToStr$qduso
|
|
dec dword[esp+8] ;decrease PRECISION
|
|
jz @f ;to avoid looping
|
|
cmp word[eax],'#'
|
|
je @b ;if the number does not fit, we try to translate with less precision
|
|
@@:
|
|
add esp,16
|
|
stdcall str_cat, esi,eax
|
|
inc dword[ebp-4]
|
|
.4:
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
mov eax,[ebp+8]
|
|
add ecx,[eax+NeuralNetwork.layers]
|
|
mov ecx,[ecx+Layer.n_size]
|
|
cmp ecx,[ebp-4]
|
|
ja .3
|
|
stdcall str_cat, esi,txt_sqbr
|
|
inc ebx
|
|
.5:
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov ecx,[ebp+8]
|
|
add eax,[ecx+NeuralNetwork.layers]
|
|
cmp ebx,[eax+Layer.c_size]
|
|
jb .cycle_3
|
|
.6:
|
|
stdcall str_cat, esi,txt_sqbr_fbr_zap
|
|
inc edi
|
|
.7:
|
|
mov eax,[ebp+8]
|
|
cmp edi,[eax+NeuralNetwork.layers_length]
|
|
jb .cycle_0
|
|
stdcall str_cat, esi,txt_nl_t_sqbr
|
|
.end_f:
|
|
pop edi esi ebx
|
|
mov esp,ebp
|
|
pop ebp
|
|
ret 12
|
|
|
|
;+ 8 NeuralNetwork* o
|
|
align 16
|
|
NNP_GetMaxLLen:
|
|
push ebp
|
|
mov ebp,esp
|
|
push ebx esi
|
|
mov ebx,[ebp+8]
|
|
cmp dword[ebx+NeuralNetwork.layers_length],1
|
|
jge .1
|
|
xor eax,eax
|
|
jmp .end_f
|
|
.1:
|
|
mov edx,[ebx+NeuralNetwork.layers]
|
|
lea eax,[edx+sizeof.Layer]
|
|
mov ecx,[edx]
|
|
mov edx,1 ;i=1
|
|
jmp .3
|
|
.cycle_0: ;for (i=1; i < o->layers_length; i++)
|
|
mov esi,[eax]
|
|
cmp esi,ecx
|
|
jbe .2
|
|
mov ecx,esi
|
|
.2:
|
|
inc edx
|
|
add eax,sizeof.Layer
|
|
.3:
|
|
cmp edx,[ebx+NeuralNetwork.layers_length]
|
|
jl .cycle_0
|
|
mov eax,ecx
|
|
.end_f:
|
|
pop esi ebx ebp
|
|
ret 4
|
|
|
|
;+ 8 NeuralNetwork* o
|
|
;+12 unsigned long fmt
|
|
;+16 void* m_data
|
|
align 16
|
|
NNP_SetMemData:
|
|
push ebp
|
|
mov ebp,esp
|
|
add esp,-12
|
|
push ebx esi edi
|
|
mov eax,[ebp+16]
|
|
mov edx,[ebp+12]
|
|
; cmp edx,NNP_FF_BIN
|
|
; jne @f
|
|
;...
|
|
;@@:
|
|
cmp edx,NNP_FF_JSON
|
|
jne .9
|
|
stdcall @@strstr$qpxct1, eax,txt_learningRate
|
|
add esp,8
|
|
mov esi,eax
|
|
stdcall @@strstr$qpxct1, esi,txt_layers_length
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,1
|
|
jmp .end_f
|
|
@@:
|
|
stdcall @@strchr$qpxci, esi,':'
|
|
add esp,8
|
|
mov ebx,eax
|
|
test ebx,ebx
|
|
jne @f
|
|
mov eax,2
|
|
jmp .end_f
|
|
@@:
|
|
inc ebx
|
|
stdcall @@strchr$qpxci, esi,','
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,3
|
|
jmp .end_f
|
|
@@:
|
|
mov byte[esi],0
|
|
inc esi
|
|
stdcall @@StrToInt$qpc, ebx
|
|
pop ecx
|
|
mov dword[ebp-4],eax
|
|
;lea eax,[ebp-4]
|
|
;stdcall [_scanf], ebx,txt_pri_zap,eax
|
|
;add esp,12
|
|
mov eax,[ebp+8]
|
|
mov edx,[eax+12]
|
|
cmp edx,[ebp-4]
|
|
je @f
|
|
mov eax,txt_err_layers_neq
|
|
jmp .end_f
|
|
@@:
|
|
xor edi,edi ;i=0
|
|
jmp .8
|
|
.cycle_0: ;for(i=0;i<o->layers_length;i++)
|
|
stdcall @@strstr$qpxct1, esi,txt_c_size
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,txt_err_c_size
|
|
jmp .end_f
|
|
@@:
|
|
stdcall @@strchr$qpxci, esi,':'
|
|
add esp,8
|
|
mov ebx,eax
|
|
test ebx,ebx
|
|
jne @f
|
|
mov eax,6
|
|
jmp .end_f
|
|
@@:
|
|
inc ebx
|
|
stdcall @@strchr$qpxci, esi,','
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,7
|
|
jmp .end_f
|
|
@@:
|
|
mov byte[esi],0
|
|
inc esi
|
|
stdcall @@StrToInt$qpc, ebx
|
|
pop ecx
|
|
mov dword[ebp-4],eax
|
|
stdcall @@strstr$qpxct1, esi,txt_n_size
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,8
|
|
jmp .end_f
|
|
@@:
|
|
stdcall @@strchr$qpxci, esi,':'
|
|
add esp,8
|
|
mov ebx,eax
|
|
test ebx,ebx
|
|
jne @f
|
|
mov eax,9
|
|
jmp .end_f
|
|
@@:
|
|
inc ebx
|
|
stdcall @@strchr$qpxci, esi,','
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,10
|
|
jmp .end_f
|
|
@@:
|
|
mov byte[esi],0
|
|
inc esi
|
|
stdcall @@StrToInt$qpc,ebx
|
|
pop ecx
|
|
mov dword[ebp-8],eax
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8]
|
|
add eax,[edx+NeuralNetwork.layers]
|
|
mov edx,[eax+Layer.c_size]
|
|
cmp edx,[ebp-4]
|
|
jne @f
|
|
mov edx,[eax+Layer.n_size]
|
|
cmp edx,[ebp-8]
|
|
je .1
|
|
@@:
|
|
mov ecx,[ebp+8]
|
|
stdcall NNP_GetMaxLLen,ecx
|
|
mov ecx,edi
|
|
imul ecx,sizeof.Layer
|
|
mov ebx,eax
|
|
mov eax,[ebp+8]
|
|
mov edx,[eax+NeuralNetwork.layers]
|
|
add edx,ecx
|
|
stdcall Layer_Destroy,edx
|
|
mov eax,[ebp-8]
|
|
push eax
|
|
mov edx,[ebp-4]
|
|
push edx
|
|
mov edx,edi
|
|
imul edx,sizeof.Layer
|
|
mov ecx,[ebp+8]
|
|
mov eax,[ecx+NeuralNetwork.layers]
|
|
add eax,edx
|
|
stdcall Layer_Create,eax
|
|
cmp ebx,[ebp-4] ;if(n>s || k>s)
|
|
jb @f
|
|
cmp ebx,[ebp-8]
|
|
jae .1
|
|
@@:
|
|
mov edx,[ebp+8]
|
|
mov ecx,[edx+NeuralNetwork.errors]
|
|
cmp ecx,[edx+NeuralNetwork.errorsNext]
|
|
jl @f
|
|
mov ecx,[edx+NeuralNetwork.errorsNext]
|
|
@@:
|
|
mov ebx,[ebp-4]
|
|
cmp ebx,[ebp-8]
|
|
jge @f
|
|
mov ebx,[ebp-8]
|
|
@@:
|
|
shl ebx,4
|
|
stdcall [mem.realloc], ecx,ebx
|
|
mov edx,[ebp+8]
|
|
mov dword[edx+NeuralNetwork.errors],eax
|
|
shr ebx,1
|
|
add eax,ebx
|
|
mov dword[edx+NeuralNetwork.errorsNext],eax
|
|
stdcall [mem.realloc], [edx+NeuralNetwork.gradients],ebx
|
|
mov edx,[ebp+8]
|
|
mov dword[edx+NeuralNetwork.gradients],eax
|
|
shr ebx,1
|
|
stdcall [mem.realloc], [edx+NeuralNetwork.deltas],ebx
|
|
mov edx,[ebp+8]
|
|
mov dword[edx+NeuralNetwork.deltas],eax
|
|
.1:
|
|
stdcall @@strstr$qpxct1, esi,txt_biases
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,11
|
|
jmp .end_f
|
|
@@:
|
|
stdcall @@strchr$qpxci, esi,'['
|
|
add esp,8
|
|
mov ebx,eax
|
|
test ebx,ebx
|
|
jne @f
|
|
mov eax,txt_err_sqbrl_b1
|
|
jmp .end_f
|
|
@@:
|
|
inc ebx
|
|
xor edx,edx
|
|
mov dword[ebp-8],edx
|
|
jmp .4
|
|
.2:
|
|
dec edx
|
|
cmp eax,edx
|
|
jae @f
|
|
stdcall @@strchr$qpxci, ebx,','
|
|
add esp,8
|
|
mov esi,eax
|
|
jmp .3
|
|
@@:
|
|
stdcall @@strchr$qpxci, ebx,']'
|
|
add esp,8
|
|
mov esi,eax
|
|
.3:
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,13
|
|
jmp .end_f
|
|
@@:
|
|
mov byte[esi],0
|
|
stdcall @@StrToDouble$qpc,ebx
|
|
pop ecx
|
|
mov edx,edi
|
|
imul edx,sizeof.Layer
|
|
mov ecx,[ebp+8]
|
|
lea ebx,[esi+1]
|
|
mov eax,[ecx+NeuralNetwork.layers]
|
|
mov ecx,[ebp-8]
|
|
mov edx,[eax+edx+Layer.biases]
|
|
fstp qword[edx+8*ecx]
|
|
inc dword[ebp-8]
|
|
.4:
|
|
mov edx,edi
|
|
imul edx,sizeof.Layer
|
|
mov ecx,[ebp+8]
|
|
add edx,[ecx+NeuralNetwork.layers]
|
|
mov edx,[edx+Layer.c_size]
|
|
mov eax,[ebp-8]
|
|
cmp edx,eax
|
|
ja .2
|
|
mov esi,ebx
|
|
stdcall @@strstr$qpxct1, esi,txt_weights
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,14
|
|
jmp .end_f
|
|
@@:
|
|
stdcall @@strchr$qpxci, esi,'['
|
|
add esp,8
|
|
mov esi,eax
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,txt_err_sqbrl_w1
|
|
jmp .end_f
|
|
@@:
|
|
inc esi
|
|
xor edx,edx
|
|
mov dword[ebp-8],edx ;k=0
|
|
jmp .7
|
|
.cycle_1: ;for(k=0;k<o->layers[i].c_size;k++)
|
|
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8]
|
|
add eax,[edx+NeuralNetwork.layers]
|
|
mov eax,[eax+Layer.n_size]
|
|
or eax,eax
|
|
jnz .end_null_we
|
|
inc dword[ebp-8] ;k++
|
|
jmp .7 ;if 'weights' is null array
|
|
.end_null_we:
|
|
|
|
stdcall @@strchr$qpxci, esi,'['
|
|
add esp,8
|
|
mov ebx,eax
|
|
test ebx,ebx
|
|
jne @f
|
|
mov eax,txt_err_sqbrl_w2
|
|
jmp .end_f
|
|
@@:
|
|
inc ebx
|
|
xor edx,edx
|
|
mov dword[ebp-12],edx ;j=0
|
|
jmp .6
|
|
.cycle_2: ;for(j=0;j<o->layers[i].n_size;j++)
|
|
dec edx
|
|
cmp eax,edx ;eax = j, edx = n_size-1
|
|
jae @f
|
|
stdcall @@strchr$qpxci, ebx,','
|
|
add esp,8
|
|
mov esi,eax
|
|
jmp .5
|
|
@@:
|
|
stdcall @@strchr$qpxci, ebx,']'
|
|
add esp,8
|
|
mov esi,eax
|
|
.5:
|
|
test esi,esi
|
|
jne @f
|
|
mov eax,txt_err_sqbrr_w2
|
|
jmp .end_f
|
|
@@:
|
|
mov byte[esi],0
|
|
stdcall @@StrToDouble$qpc,ebx
|
|
pop ecx
|
|
mov edx,edi
|
|
imul edx,sizeof.Layer
|
|
mov ecx,[ebp+8]
|
|
lea ebx,[esi+1]
|
|
mov eax,[ecx+NeuralNetwork.layers]
|
|
mov ecx,[ebp-8]
|
|
mov edx,[eax+edx+Layer.weights]
|
|
mov eax,[edx+4*ecx]
|
|
mov edx,[ebp-12]
|
|
fstp qword[eax+8*edx]
|
|
inc dword[ebp-12]
|
|
.6:
|
|
mov edx,edi
|
|
imul edx,sizeof.Layer
|
|
mov ecx,[ebp+8]
|
|
add edx,[ecx+NeuralNetwork.layers]
|
|
mov edx,[edx+Layer.n_size]
|
|
mov eax,[ebp-12]
|
|
cmp edx,eax
|
|
ja .cycle_2
|
|
mov esi,ebx
|
|
inc dword[ebp-8]
|
|
.7:
|
|
mov eax,edi
|
|
imul eax,sizeof.Layer
|
|
mov edx,[ebp+8]
|
|
add eax,[edx+NeuralNetwork.layers]
|
|
mov eax,[eax+Layer.c_size]
|
|
cmp eax,[ebp-8]
|
|
ja .cycle_1
|
|
inc edi
|
|
.8:
|
|
mov edx,[ebp+8]
|
|
cmp edi,[edx+NeuralNetwork.layers_length]
|
|
jb .cycle_0
|
|
xor eax,eax
|
|
jmp .end_f
|
|
.9:
|
|
mov eax,1000
|
|
.end_f:
|
|
pop edi esi ebx
|
|
mov esp,ebp
|
|
pop ebp
|
|
ret 12
|
|
|
|
align 16
|
|
Layer_Destroy:
|
|
push ebp
|
|
mov ebp,esp
|
|
push ebx esi
|
|
mov esi,[ebp+8]
|
|
push dword[esi+Layer.neurons]
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
push dword[esi+Layer.biases]
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
xor ebx,ebx
|
|
jmp @f
|
|
.cycle_1:
|
|
mov eax,[esi+Layer.weights]
|
|
push dword[eax+4*ebx]
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
inc ebx
|
|
@@:
|
|
cmp ebx,[esi+Layer.c_size]
|
|
jb .cycle_1
|
|
push dword[esi+Layer.weights]
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
pop esi ebx ebp
|
|
ret 4
|
|
|
|
align 16
|
|
NNP_Destroy:
|
|
push ebp
|
|
mov ebp,esp
|
|
push ebx esi
|
|
mov esi,[ebp+8]
|
|
xor ebx,ebx
|
|
jmp @f
|
|
.cycle_1:
|
|
mov eax,ebx
|
|
imul eax,sizeof.Layer
|
|
add eax,[esi+NeuralNetwork.layers]
|
|
push eax
|
|
call Layer_Destroy
|
|
inc ebx
|
|
@@:
|
|
cmp ebx,[esi+NeuralNetwork.layers_length]
|
|
jb .cycle_1
|
|
push dword[esi+NeuralNetwork.layers]
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
;
|
|
mov ecx,[esi+NeuralNetwork.errors]
|
|
cmp ecx,[esi+NeuralNetwork.errorsNext]
|
|
jl @f
|
|
mov ecx,[esi+NeuralNetwork.errorsNext]
|
|
@@:
|
|
push ecx
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
;
|
|
push dword[esi+NeuralNetwork.gradients]
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
;
|
|
push dword[esi+NeuralNetwork.deltas]
|
|
call @$bdele$qpv
|
|
pop ecx
|
|
pop esi ebx ebp
|
|
ret 4
|
|
|
|
|
|
align 16
|
|
EXPORTS:
|
|
dd sz_lib_init, lib_init
|
|
dd sz_create, NNP_Create
|
|
dd sz_reset, NNP_Reset
|
|
dd sz_feedforward, NNP_FeedForward
|
|
dd sz_backpropagation, NNP_BackPropagation
|
|
dd sz_getmemdata, NNP_GetMemData
|
|
dd sz_setmemdata, NNP_SetMemData
|
|
dd sz_destroy, NNP_Destroy
|
|
dd 0,0
|
|
sz_lib_init db 'lib_init',0
|
|
sz_create db 'NNP_Create',0
|
|
sz_reset db 'NNP_Reset',0
|
|
sz_feedforward db 'NNP_FeedForward',0
|
|
sz_backpropagation db 'NNP_BackPropagation',0
|
|
sz_getmemdata db 'NNP_GetMemData',0
|
|
sz_setmemdata db 'NNP_SetMemData',0
|
|
sz_destroy db 'NNP_Destroy',0
|