ton/IronpenGPU
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

alif forward

Browse Source
This commit is contained in:
ton
2023-07-23 15:39:48 +07:00
parent b7c87bd0fa
commit bdec057886
2 changed files with 162 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
src/forward.jl
View File

@@ -43,44 +43,32 @@ function (kfn::kfn_1)(input::AbstractArray)
kfn.lif_phi,
kfn.lif_epsilonRec,
kfn.lif_refractoryCounter,
kfn.lif_refractoryDuration,)
kfn.lif_refractoryDuration,
kfn.lif_gammaPd)
alifForward( kfn.zit,
kfn.alif_zit,
kfn.alif_wRec,
kfn.alif_vt0,
kfn.alif_vt1,
kfn.alif_vth,
kfn.alif_avth,
kfn.alif_vRest,
kfn.alif_zt1,
kfn.alif_alpha,
kfn.alif_phi,
kfn.alif_epsilonRec,
kfn.alif_epsilonRecA,
kfn.alif_refractoryCounter,
kfn.alif_refractoryDuration,
kfn.alif_a,
kfn.alif_beta,
kfn.alif_rho,
kfn.alif_gammaPd)
error("debug end kfn forward")
# kfn.lif_zit = GeneralUtils.matMul_3Dto4D_batchwise(kfn.zit,
# ones(size(kfn.zit)[1], size(kfn.zit)[2], size(kfn.lif_wRec)[3], size(kfn.zit)[3]))
# check active/inactive neurons
# refractoryStatus!(kfn.lif_refractoryCounter, kfn.lif_refractoryActive, kfn.lif_refractoryInactive)
# refractoryStatus!(kfn.alif_refractoryCounter, kfn.alif_refractoryActive, kfn.alif_refractoryInactive)
# a = kfn.lif_refractoryActive .* kfn.lif_wRec
# lifForward.(kfn.lif_refractoryCounter, kfn.zit0, kfn.zit1,
# kfn.lif_vt0, kfn.lif_vt1, kfn.lif_alpha, kfn.lif_recSignal)
# kfn.lif_recSignal .= GeneralUtils.sumAlongDim3(
# GeneralUtils.matMul_3Dto4D_batchwise(kfn.zit1, kfn.lif_refractoryActive .* kfn.lif_wRec))
# kfn.lif_vt1 = (kfn.lif_alpha .* kfn.lif_vt0) .+ kfn.lif_recSignal
# GeneralUtils.batchMatEleMul(kfn.zit1, kfn.alif_wRec, resultStorage=kfn.alif_recSignal)
end
@@ -96,39 +84,114 @@ function lifForward(zit,
lif_phi,
lif_epsilonRec,
lif_refractoryCounter,
lif_refractoryDuration,)
lif_refractoryDuration,
lif_gammaPd)
_, _, d3, d4 = size(lif_wRec)
lif_zit .= zit .* ones(size(lif_wRec)...) # project zit into lif_zit
for j in 1:d4, i in 1:d3 # compute along neurons axis of every batch
if view(lif_refractoryCounter, :, :, i, j)[1] > 0 # refractory period is active
view(lif_refractoryCounter, :, :, i, j)[1] -= 1
view(lif_zt1, :, :, i, j)[1] = 0
view(lif_vt1, :, :, i, j)[1] = view(lif_alpha, :, :, i, j)[1] * view(lif_vt0, :, :, i, j)[1]
view(lif_vt1, :, :, i, j)[1] =
view(lif_alpha, :, :, i, j)[1] * view(lif_vt0, :, :, i, j)[1]
view(lif_phi, :, :, i, j)[1] = 0.0
view(lif_epsilonRec, :, :, i, j) .= view(lif_alpha, :, :, i, j)[1] .*
view(lif_epsilonRec, :, :, i, j)
else # refractory period is inactive
view(lif_vt1, :, :, i, j)[1] =
(view(lif_alpha, :, :, i, j)[1] * view(lif_vt0,:, :, i, j)[1]) +
sum(view(lif_zit, :, :, i, j) .* view(lif_wRec, :, :, i, j))
(view(lif_alpha, :, :, i, j)[1] * view(lif_vt0,:, :, i, j)[1]) +
sum(view(lif_zit, :, :, i, j) .* view(lif_wRec, :, :, i, j))
if view(lif_vt1, :, :, i, j)[1] > view(lif_vth, :, :, i, j)[1]
view(lif_zt1, :, :, i, j)[1] = 1
view(lif_refractoryCounter, :, :, i, j)[1] = view(lif_refractoryDuration, :, :, i, j)[1]
view(lif_refractoryCounter, :, :, i, j)[1] =
view(lif_refractoryDuration, :, :, i, j)[1]
view(lif_firingCounter, :, :, i, j)[1] += 1
view(lif_vt1, :, :, i, j)[1] = view(lif_vRest, :, :, i, j)[1]
else
view(lif_zt1, :, :, i, j)[1] = 0
end
# there is a difference from alif formula
view(lif_phi, :, :, i, j)[1] =
(view(lif_gammaPd, :, :, i, j)[1] / view(lif_vth, :, :, i, j)[1]) *
max(0, 1 - ((view(lif_vt1, :, :, i, j)[1] - view(lif_vth, :, :, i, j)[1]) /
view(lif_vth, :, :, i, j)[1]))
view(lif_epsilonRec, :, :, i, j) .=
(view(lif_alpha, :, :, i, j)[1] .* view(lif_epsilonRec, :, :, i, j)) +
view(lif_zit, :, :, i, j)
end
end
error("debug end -> LIF forward")
end
function alifForward(zit,
alif_zit,
alif_wRec,
alif_vt0,
alif_vt1,
alif_vth,
alif_avth,
alif_vRest,
alif_zt1,
alif_alpha,
alif_phi,
alif_epsilonRec,
alif_epsilonRecA,
alif_refractoryCounter,
alif_refractoryDuration,
alif_a,
alif_beta,
alif_rho,
alif_gammaPd)
_, _, d3, d4 = size(alif_wRec)
alif_zit .= zit .* ones(size(alif_wRec)...) # project zit into alif_zit
for j in 1:d4, i in 1:d3 # compute along neurons axis of every batch
if view(alif_refractoryCounter, :, :, i, j)[1] > 0 # refractory period is active
view(alif_refractoryCounter, :, :, i, j)[1] -= 1
view(alif_zt1, :, :, i, j)[1] = 0
view(alif_vt1, :, :, i, j)[1] = view(alif_alpha, :, :, i, j)[1] *
view(alif_vt0, :, :, i, j)[1]
view(alif_phi, :, :, i, j)[1] = 0.0
view(alif_epsilonRec, :, :, i, j) .= view(alif_alpha, :, :, i, j)[1] .*
view(alif_epsilonRec, :, :, i, j)
view(alif_a, :, :, i, j)[1] =
(view(alif_rho, :, :, i, j)[1] * view(alif_a, :, :, i, j)[1]) + 0
else # refractory period is inactive
view(alif_vt1, :, :, i, j)[1] =
(view(alif_alpha, :, :, i, j)[1] * view(alif_vt0,:, :, i, j)[1]) +
sum(view(alif_zit, :, :, i, j) .* view(alif_wRec, :, :, i, j))
view(alif_avth, :, :, i, j)[1] = view(alif_vth, :, :, i, j)[1] +
(view(alif_beta, :, :, i, j)[1] * view(alif_a, :, :, i, j)[1])
if view(alif_vt1, :, :, i, j)[1] > view(alif_avth, :, :, i, j)[1]
view(alif_zt1, :, :, i, j)[1] = 1
view(alif_refractoryCounter, :, :, i, j)[1] =
view(alif_refractoryDuration, :, :, i, j)[1]
view(alif_firingCounter, :, :, i, j)[1] += 1
view(alif_vt1, :, :, i, j)[1] = view(alif_vRest, :, :, i, j)[1]
view(alif_a, :, :, i, j)[1] = (view(alif_rho, :, :, i, j)[1] *
view(alif_a, :, :, i, j)[1]) + 1
else
view(alif_zt1, :, :, i, j)[1] = 0
view(alif_a, :, :, i, j)[1] =
(view(alif_rho, :, :, i, j)[1] * view(alif_a, :, :, i, j)[1]) + 0
end
# there is a difference from alif formula
view(alif_phi, :, :, i, j)[1] =
(view(alif_gammaPd, :, :, i, j)[1] / view(alif_vth, :, :, i, j)[1]) *
max(0, 1 - ((view(alif_vt1, :, :, i, j)[1] - view(alif_avth, :, :, i, j)[1]) /
view(alif_vth, :, :, i, j)[1]))
view(alif_epsilonRec, :, :, i, j) .=
(view(alif_alpha, :, :, i, j) .* view(alif_epsilonRec, :, :, i, j)) +
view(alif_zit, :, :, i, j)
view(alif_epsilonRecA, :, :, i, j) .=
(view(alif_phi, :, :, i, j)[1] .* view(alif_epsilonRec, :, :, i, j)) +
((view(alif_rho, :, :, i, j)[1] -
(view(alif_phi, :, :, i, j)[1] * view(alif_beta, :, :, i, j)[1])) .*
view(alif_epsilonRecA, :, :, i, j))
end
end
end