From 50df91310698b1f5d513ee9ea8010392694f10e8 Mon Sep 17 00:00:00 2001 From: ton Date: Sun, 30 Jul 2023 06:17:13 +0700 Subject: [PATCH] alif forward() --- src/forward.jl | 387 +++++++++++++++++++++++++++++++++---------------- src/type.jl | 151 +++++++++++-------- 2 files changed, 352 insertions(+), 186 deletions(-) diff --git a/src/forward.jl b/src/forward.jl index aa0678a..bf89c8b 100644 --- a/src/forward.jl +++ b/src/forward.jl @@ -36,8 +36,8 @@ function (kfn::kfn_1)(input::AbstractArray) lifForward( kfn.zit, kfn.lif_zit, - kfn.lif_wRec, - kfn.lif_vt0, + kfn.lif_wRec, + kfn.lif_vt0, kfn.lif_vt1, kfn.lif_vth, kfn.lif_vRest, @@ -49,29 +49,49 @@ function (kfn::kfn_1)(input::AbstractArray) kfn.lif_refractoryDuration, kfn.lif_gammaPd, kfn.lif_firingCounter, - kfn.lif_arraySize, - kfn.lif_arrayProjection3DTo4D) + kfn.lif_arrayProjection3DTo4D, + kfn.lif_recSignal, + kfn.lif_decayed_vt0, + kfn.lif_decayed_epsilonRec, + kfn.lif_vt1_diff_vth, + kfn.lif_vt1_diff_vth_div_vth, + kfn.lif_gammaPd_div_vth, + kfn.lif_phiActivation) 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, - kfn.alif_firingCounter) + kfn.alif_zit, + kfn.alif_wRec, + kfn.alif_vt0, + kfn.alif_vt1, + kfn.alif_vth, + kfn.alif_vRest, + kfn.alif_zt1, + kfn.alif_alpha, + kfn.alif_phi, + kfn.alif_epsilonRec, + kfn.alif_refractoryCounter, + kfn.alif_refractoryDuration, + kfn.alif_gammaPd, + kfn.alif_firingCounter, + kfn.alif_arrayProjection3DTo4D, + kfn.alif_recSignal, + kfn.alif_decayed_vt0, + kfn.alif_decayed_epsilonRec, + kfn.alif_vt1_diff_vth, + kfn.alif_vt1_diff_vth_div_vth, + kfn.alif_gammaPd_div_vth, + kfn.alif_phiActivation, + + kfn.alif_epsilonRecA, + kfn.alif_avth, + kfn.alif_a, + kfn.alif_beta, + kfn.alif_rho, + kfn.alif_phi_x_epsilonRec, + kfn.alif_phi_x_beta, + kfn.alif_rho_diff_phi_x_beta, + kfn.alif_rho_div_phi_x_beta_x_epsilonRecA, + kfn.alif_beta_x_a) # error("DEBUG -> kfn forward") @@ -103,7 +123,74 @@ function (kfn::kfn_1)(input::AbstractArray) kfn.zit end + function lifForward(kfn_zit, + zit, + wRec, + vt0, + vt1, + vth, + vRest, + zt1, + alpha, + phi, + epsilonRec, + refractoryCounter, + refractoryDuration, + gammaPd, + firingCounter, + arrayProjection3DTo4D, + recSignal, + decayed_vt0, + decayed_epsilonRec, + vt1_diff_vth, + vt1_diff_vth_div_vth, + gammaPd_div_vth, + phiActivation) + + # project 3D kfn zit into 4D lif zit + zit .= reshape(kfn_zit, + (size(wRec, 1), size(wRec, 2), 1, size(wRec, 4))) .* arrayProjection3DTo4D + + for j in 1:size(wRec, 4), i in 1:size(wRec, 3) # compute along neurons axis of every batch + if sum(@view(refractoryCounter[:,:,i,j])) > 0 # refractory period is active + @. @views refractoryCounter[:,:,i,j] -= 1 + @. @views zt1[:,:,i,j] = 0 + @. @views vt1[:,:,i,j] = alpha[:,:,i,j] * vt0[:,:,i,j] + @. @views phi[:,:,i,j] = 0 + + # compute epsilonRec + @. @views decayed_epsilonRec[:,:,i,j] = alpha[:,:,i,j] * epsilonRec[:,:,i,j] + @. @views epsilonRec[:,:,i,j] = decayed_epsilonRec[:,:,i,j] + else # refractory period is inactive + @. @views recSignal[:,:,i,j] = zit[:,:,i,j] * wRec[:,:,i,j] + @. @views decayed_vt0[:,:,i,j] = alpha[:,:,i,j] * vt0[:,:,i,j] + @view(vt1[:,:,i,j]) .= @view(decayed_vt0[:,:,i,j]) .+ sum(@view(recSignal[:,:,i,j])) + + if sum(@view(vt1[:,:,i,j])) > sum(@view(vth[:,:,i,j])) + @. @views zt1[:,:,i,j] = 1 + @. @views refractoryCounter[:,:,i,j] = refractoryDuration[:,:,i,j] + @. @views firingCounter[:,:,i,j] += 1 + @. @views vt1[:,:,i,j] = vRest[:,:,i,j] + else + @. @views zt1[:,:,i,j] = 0 + end + + # compute phi, there is a difference from alif formula + @. @views gammaPd_div_vth[:,:,i,j] = gammaPd[:,:,i,j] / vth[:,:,i,j] + @. @views vt1_diff_vth[:,:,i,j] = vt1[:,:,i,j] - vth[:,:,i,j] + @. @views vt1_diff_vth_div_vth[:,:,i,j] = vt1_diff_vth[:,:,i,j] / vth[:,:,i,j] + @view(phiActivation[:,:,i,j]) .= max(0, 1 - sum(@view(vt1_diff_vth_div_vth[:,:,i,j]))) + @. @views phi[:,:,i,j] = gammaPd_div_vth[:,:,i,j] * phiActivation[:,:,i,j] + + # compute epsilonRec + @. @views decayed_epsilonRec[:,:,i,j] = alpha[:,:,i,j] * epsilonRec[:,:,i,j] + @. @views epsilonRec[:,:,i,j] = decayed_epsilonRec[:,:,i,j] + zit[:,:,i,j] + end + end +end + +function alifForward(kfn_zit, zit, wRec, vt0, @@ -118,119 +205,167 @@ function lifForward(kfn_zit, refractoryDuration, gammaPd, firingCounter, - arraySize, - arrayProjection3DTo4D) - - # project 3D kfn zit into 4D lif zit - zit .= reshape(kfn_zit, - (view(arraySize, 1)[1], view(arraySize, 2)[1], 1, view(arraySize, 4)[1])) .* - arrayProjection3DTo4D - # error("DEBUG -> lif forward") #WORKING - for j in 1:size(wRec, 4), i in 1:size(wRec, 3) # compute along neurons axis of every batch - if view(refractoryCounter, :, :, i, j)[1] > 0 # refractory period is active - view(refractoryCounter, :, :, i, j)[1] -= 1 - view(zt1, :, :, i, j)[1] = 0 - view(vt1, :, :, i, j)[1] = - view(alpha, :, :, i, j)[1] * view(vt0, :, :, i, j)[1] - view(phi, :, :, i, j)[1] = 0.0 - view(epsilonRec, :, :, i, j) .= view(alpha, :, :, i, j)[1] .* - view(epsilonRec, :, :, i, j) - else # refractory period is inactive - view(vt1, :, :, i, j)[1] = - (view(alpha, :, :, i, j)[1] * view(vt0,:, :, i, j)[1]) + - sum(view(zit, :, :, i, j) .* view(wRec, :, :, i, j)) - if view(vt1, :, :, i, j)[1] > view(vth, :, :, i, j)[1] - view(zt1, :, :, i, j)[1] = 1 - view(refractoryCounter, :, :, i, j)[1] = - view(refractoryDuration, :, :, i, j)[1] - view(firingCounter, :, :, i, j)[1] += 1 - view(vt1, :, :, i, j)[1] = view(vRest, :, :, i, j)[1] - else - view(zt1, :, :, i, j)[1] = 0 - end - # there is a difference from alif formula - view(phi, :, :, i, j)[1] = - (view(gammaPd, :, :, i, j)[1] / view(vth, :, :, i, j)[1]) * - max(0, 1 - ((view(vt1, :, :, i, j)[1] - view(vth, :, :, i, j)[1]) / - view(vth, :, :, i, j)[1])) - view(epsilonRec, :, :, i, j) .= - (view(alpha, :, :, i, j)[1] .* view(epsilonRec, :, :, i, j)) + - view(zit, :, :, i, j) - end - end -end + arrayProjection3DTo4D, + recSignal, + decayed_vt0, + decayed_epsilonRec, + vt1_diff_vth, + vt1_diff_vth_div_vth, + gammaPd_div_vth, + phiActivation, -function alifForward(kfn_zit, - zit, - wRec, - vt0, - vt1, - vth, - avth, - vRest, - zt1, - alpha, - phi, - epsilonRec, epsilonRecA, - refractoryCounter, - refractoryDuration, + avth, a, beta, rho, - gammaPd, - firingCounter) - d1, d2, d3, d4 = size(wRec) - zit .= reshape(kfn_zit, (d1, d2, 1, d4)) .* ones(size(wRec)...) # project zit into zit + phi_x_epsilonRec, + phi_x_beta, + rho_diff_phi_x_beta, + rho_div_phi_x_beta_x_epsilonRecA, + beta_x_a) - for j in 1:d4, i in 1:d3 # compute along neurons axis of every batch - if view(refractoryCounter, :, :, i, j)[1] > 0 # refractory period is active - view(refractoryCounter, :, :, i, j)[1] -= 1 - view(zt1, :, :, i, j)[1] = 0 - view(vt1, :, :, i, j)[1] = view(alpha, :, :, i, j)[1] * - view(vt0, :, :, i, j)[1] - view(phi, :, :, i, j)[1] = 0.0 - view(epsilonRec, :, :, i, j) .= view(alpha, :, :, i, j)[1] .* - view(epsilonRec, :, :, i, j) - view(a, :, :, i, j)[1] = - (view(rho, :, :, i, j)[1] * view(a, :, :, i, j)[1]) + 0 - else # refractory period is inactive - view(vt1, :, :, i, j)[1] = - (view(alpha, :, :, i, j)[1] * view(vt0,:, :, i, j)[1]) + - sum(view(zit, :, :, i, j) .* view(wRec, :, :, i, j)) - view(avth, :, :, i, j)[1] = view(vth, :, :, i, j)[1] + - (view(beta, :, :, i, j)[1] * view(a, :, :, i, j)[1]) - if view(vt1, :, :, i, j)[1] > view(avth, :, :, i, j)[1] - view(zt1, :, :, i, j)[1] = 1 - view(refractoryCounter, :, :, i, j)[1] = - view(refractoryDuration, :, :, i, j)[1] - view(firingCounter, :, :, i, j)[1] += 1 - view(vt1, :, :, i, j)[1] = view(vRest, :, :, i, j)[1] - view(a, :, :, i, j)[1] = (view(rho, :, :, i, j)[1] * - view(a, :, :, i, j)[1]) + 1 - else - view(zt1, :, :, i, j)[1] = 0 - view(a, :, :, i, j)[1] = - (view(rho, :, :, i, j)[1] * view(a, :, :, i, j)[1]) + 0 - end - # there is a difference from alif formula - view(phi, :, :, i, j)[1] = - (view(gammaPd, :, :, i, j)[1] / view(vth, :, :, i, j)[1]) * - max(0, 1 - ((view(vt1, :, :, i, j)[1] - view(avth, :, :, i, j)[1]) / - view(vth, :, :, i, j)[1])) - view(epsilonRec, :, :, i, j) .= - (view(alpha, :, :, i, j) .* view(epsilonRec, :, :, i, j)) + - view(zit, :, :, i, j) - view(epsilonRecA, :, :, i, j) .= - (view(phi, :, :, i, j)[1] .* view(epsilonRec, :, :, i, j)) + - ((view(rho, :, :, i, j)[1] - - (view(phi, :, :, i, j)[1] * view(beta, :, :, i, j)[1])) .* - view(epsilonRecA, :, :, i, j)) + # project 3D kfn zit into 4D lif zit + zit .= reshape(kfn_zit, + (size(wRec, 1), size(wRec, 2), 1, size(wRec, 4))) .* arrayProjection3DTo4D + + for j in 1:size(wRec, 4), i in 1:size(wRec, 3) # compute along neurons axis of every batch + if sum(@view(refractoryCounter[:,:,i,j])) > 0 # refractory period is active + @. @views refractoryCounter[:,:,i,j] -= 1 + @. @views zt1[:,:,i,j] = 0 + @. @views vt1[:,:,i,j] = alpha[:,:,i,j] * vt0[:,:,i,j] + @. @views phi[:,:,i,j] = 0 + @. @views a[:,:,i,j] = rho[:,:,i,j] * a[:,:,i,j] + + # compute epsilonRec + @. @views decayed_epsilonRec[:,:,i,j] = alpha[:,:,i,j] * epsilonRec[:,:,i,j] + @. @views epsilonRec[:,:,i,j] = decayed_epsilonRec[:,:,i,j] + + # compute epsilonRecA + @. @views phi_x_epsilonRec[:,:,i,j] = phi[:,:,i,j] * epsilonRec[:,:,i,j] + @. @views phi_x_beta[:,:,i,j] = phi[:,:,i,j] * beta[:,:,i,j] + @. @views rho_diff_phi_x_beta[:,:,i,j] = rho[:,:,i,j] - phi_x_beta[:,:,i,j] + @. @views rho_div_phi_x_beta_x_epsilonRecA[:,:,i,j] = rho_diff_phi_x_beta[:,:,i,j] * epsilonRecA[:,:,i,j] + @. @views epsilonRecA[:,:,i,j] = phi_x_epsilonRec[:,:,i,j] + rho_div_phi_x_beta_x_epsilonRecA[:,:,i,j] + + # compute avth + @. @views beta_x_a[:,:,i,j] = beta[:,:,i,j] * a[:,:,i,j] + @. @views avth[:,:,i,j] = vth[:,:,i,j] + beta_x_a[:,:,i,j] + + else # refractory period is inactive + @. @views recSignal[:,:,i,j] = zit[:,:,i,j] * wRec[:,:,i,j] + @. @views decayed_vt0[:,:,i,j] = alpha[:,:,i,j] * vt0[:,:,i,j] + @view(vt1[:,:,i,j]) .= @view(decayed_vt0[:,:,i,j]) .+ sum(@view(recSignal[:,:,i,j])) + + # compute avth + @. @views beta_x_a[:,:,i,j] = beta[:,:,i,j] * a[:,:,i,j] + @. @views avth[:,:,i,j] = vth[:,:,i,j] + beta_x_a[:,:,i,j] + + if sum(@view(vt1[:,:,i,j])) > sum(@view(avth[:,:,i,j])) + @. @views zt1[:,:,i,j] = 1 + @. @views refractoryCounter[:,:,i,j] = refractoryDuration[:,:,i,j] + @. @views firingCounter[:,:,i,j] += 1 + @. @views vt1[:,:,i,j] = vRest[:,:,i,j] + @. @views a[:,:,i,j] = rho[:,:,i,j] * a[:,:,i,j] + @. @views a[:,:,i,j] = a[:,:,i,j] += 1 + else + @. @views zt1[:,:,i,j] = 0 + @. @views a[:,:,i,j] = rho[:,:,i,j] * a[:,:,i,j] + end + + # compute phi, there is a difference from alif formula + @. @views gammaPd_div_vth[:,:,i,j] = gammaPd[:,:,i,j] / vth[:,:,i,j] + @. @views vt1_diff_vth[:,:,i,j] = vt1[:,:,i,j] - vth[:,:,i,j] + @. @views vt1_diff_vth_div_vth[:,:,i,j] = vt1_diff_vth[:,:,i,j] / vth[:,:,i,j] + @view(phiActivation[:,:,i,j]) .= max(0, 1 - sum(@view(vt1_diff_vth_div_vth[:,:,i,j]))) + @. @views phi[:,:,i,j] = gammaPd_div_vth[:,:,i,j] * phiActivation[:,:,i,j] + + # compute epsilonRec + @. @views decayed_epsilonRec[:,:,i,j] = alpha[:,:,i,j] * epsilonRec[:,:,i,j] + @. @views epsilonRec[:,:,i,j] = decayed_epsilonRec[:,:,i,j] + zit[:,:,i,j] + + # compute epsilonRecA + @. @views phi_x_epsilonRec[:,:,i,j] = phi[:,:,i,j] * epsilonRec[:,:,i,j] + @. @views phi_x_beta[:,:,i,j] = phi[:,:,i,j] * beta[:,:,i,j] + @. @views rho_diff_phi_x_beta[:,:,i,j] = rho[:,:,i,j] - phi_x_beta[:,:,i,j] + @. @views rho_div_phi_x_beta_x_epsilonRecA[:,:,i,j] = rho_diff_phi_x_beta[:,:,i,j] * epsilonRecA[:,:,i,j] + @. @views epsilonRecA[:,:,i,j] = phi_x_epsilonRec[:,:,i,j] + rho_div_phi_x_beta_x_epsilonRecA[:,:,i,j] + end end - end end +# function alifForward(kfn_zit, +# zit, +# wRec, +# vt0, +# vt1, +# vth, +# avth, +# vRest, +# zt1, +# alpha, +# phi, +# epsilonRec, +# epsilonRecA, +# refractoryCounter, +# refractoryDuration, +# a, +# beta, +# rho, +# gammaPd, +# firingCounter) +# d1, d2, d3, d4 = size(wRec) +# zit .= reshape(kfn_zit, (d1, d2, 1, d4)) .* ones(size(wRec)...) # project zit into zit + +# for j in 1:d4, i in 1:d3 # compute along neurons axis of every batch +# if view(refractoryCounter, :, :, i, j)[1] > 0 # refractory period is active +# view(refractoryCounter, :, :, i, j)[1] -= 1 +# view(zt1, :, :, i, j)[1] = 0 +# view(vt1, :, :, i, j)[1] = view(alpha, :, :, i, j)[1] * +# view(vt0, :, :, i, j)[1] +# view(phi, :, :, i, j)[1] = 0.0 +# view(epsilonRec, :, :, i, j) .= view(alpha, :, :, i, j)[1] .* +# view(epsilonRec, :, :, i, j) +# view(a, :, :, i, j)[1] = +# (view(rho, :, :, i, j)[1] * view(a, :, :, i, j)[1]) + 0 +# else # refractory period is inactive +# view(vt1, :, :, i, j)[1] = +# (view(alpha, :, :, i, j)[1] * view(vt0,:, :, i, j)[1]) + +# sum(view(zit, :, :, i, j) .* view(wRec, :, :, i, j)) +# view(avth, :, :, i, j)[1] = view(vth, :, :, i, j)[1] + +# (view(beta, :, :, i, j)[1] * view(a, :, :, i, j)[1]) +# if view(vt1, :, :, i, j)[1] > view(avth, :, :, i, j)[1] +# view(zt1, :, :, i, j)[1] = 1 +# view(refractoryCounter, :, :, i, j)[1] = +# view(refractoryDuration, :, :, i, j)[1] +# view(firingCounter, :, :, i, j)[1] += 1 +# view(vt1, :, :, i, j)[1] = view(vRest, :, :, i, j)[1] +# view(a, :, :, i, j)[1] = (view(rho, :, :, i, j)[1] * +# view(a, :, :, i, j)[1]) + 1 +# else +# view(zt1, :, :, i, j)[1] = 0 +# view(a, :, :, i, j)[1] = +# (view(rho, :, :, i, j)[1] * view(a, :, :, i, j)[1]) + 0 +# end + +# # there is a difference from alif formula +# view(phi, :, :, i, j)[1] = +# (view(gammaPd, :, :, i, j)[1] / view(vth, :, :, i, j)[1]) * +# max(0, 1 - ((view(vt1, :, :, i, j)[1] - view(avth, :, :, i, j)[1]) / +# view(vth, :, :, i, j)[1])) +# view(epsilonRec, :, :, i, j) .= +# (view(alpha, :, :, i, j) .* view(epsilonRec, :, :, i, j)) + +# view(zit, :, :, i, j) +# view(epsilonRecA, :, :, i, j) .= +# (view(phi, :, :, i, j)[1] .* view(epsilonRec, :, :, i, j)) + +# ((view(rho, :, :, i, j)[1] - +# (view(phi, :, :, i, j)[1] * view(beta, :, :, i, j)[1])) .* +# view(epsilonRecA, :, :, i, j)) +# end +# end +# end + function onForward(kfn_zit, zit, wOut, diff --git a/src/type.jl b/src/type.jl index 847e88a..161add4 100644 --- a/src/type.jl +++ b/src/type.jl @@ -50,13 +50,12 @@ Base.@kwdef mutable struct kfn_1 <: knowledgeFn lif_wRecChange::Union{AbstractArray, Nothing} = nothing lif_firingCounter::Union{AbstractArray, Nothing} = nothing - lif_arraySize::Union{AbstractArray, Nothing} = nothing # pre-allocation array lif_arrayProjection3DTo4D::Union{AbstractArray, Nothing} = nothing # use to project 3d array to 4d lif_recSignal::Union{AbstractArray, Nothing} = nothing - lif_decayed_Vt0::Union{AbstractArray, Nothing} = nothing - lif_decayed_EpsilonRec::Union{AbstractArray, Nothing} = nothing + lif_decayed_vt0::Union{AbstractArray, Nothing} = nothing + lif_decayed_epsilonRec::Union{AbstractArray, Nothing} = nothing lif_vt1_diff_vth::Union{AbstractArray, Nothing} = nothing lif_vt1_diff_vth_div_vth::Union{AbstractArray, Nothing} = nothing lif_gammaPd_div_vth::Union{AbstractArray, Nothing} = nothing @@ -71,7 +70,6 @@ Base.@kwdef mutable struct kfn_1 <: knowledgeFn alif_vt0::Union{AbstractArray, Nothing} = nothing alif_vt1::Union{AbstractArray, Nothing} = nothing alif_vth::Union{AbstractArray, Nothing} = nothing - alif_avth::Union{AbstractArray, Nothing} = nothing alif_vRest::Union{AbstractArray, Nothing} = nothing alif_zt0::Union{AbstractArray, Nothing} = nothing alif_zt1::Union{AbstractArray, Nothing} = nothing @@ -82,20 +80,37 @@ Base.@kwdef mutable struct kfn_1 <: knowledgeFn alif_tau_m::Union{AbstractFloat, Nothing} = nothing alif_phi::Union{AbstractArray, Nothing} = nothing alif_epsilonRec::Union{AbstractArray, Nothing} = nothing - alif_epsilonRecA::Union{AbstractArray, Nothing} = nothing alif_eRec::Union{AbstractArray, Nothing} = nothing alif_eta::Union{AbstractArray, Nothing} = nothing alif_gammaPd::Union{AbstractArray, Nothing} = nothing alif_wRecChange::Union{AbstractArray, Nothing} = nothing alif_firingCounter::Union{AbstractArray, Nothing} = nothing - alif_arraySize::Union{AbstractArray, Nothing} = nothing + + # pre-allocation array alif_arrayProjection3DTo4D::Union{AbstractArray, Nothing} = nothing # use to project 3d array to 4d + alif_recSignal::Union{AbstractArray, Nothing} = nothing + alif_decayed_vt0::Union{AbstractArray, Nothing} = nothing + alif_decayed_epsilonRec::Union{AbstractArray, Nothing} = nothing + alif_vt1_diff_vth::Union{AbstractArray, Nothing} = nothing + alif_vt1_diff_vth_div_vth::Union{AbstractArray, Nothing} = nothing + alif_gammaPd_div_vth::Union{AbstractArray, Nothing} = nothing + alif_phiActivation::Union{AbstractArray, Nothing} = nothing + # alif specific variables + alif_epsilonRecA::Union{AbstractArray, Nothing} = nothing + alif_avth::Union{AbstractArray, Nothing} = nothing alif_a::Union{AbstractArray, Nothing} = nothing # threshold adaptation alif_beta::Union{AbstractArray, Nothing} = nothing # β, constant, value from paper alif_rho::Union{AbstractArray, Nothing} = nothing # ρ, threshold adaptation decay factor alif_tau_a::Union{AbstractFloat, Nothing} = nothing # τ_a, adaption time constant in millisecond + + # alif specific pre-allocation array + alif_phi_x_epsilonRec::Union{AbstractArray, Nothing} = nothing + alif_phi_x_beta::Union{AbstractArray, Nothing} = nothing + alif_rho_diff_phi_x_beta::Union{AbstractArray, Nothing} = nothing + alif_rho_div_phi_x_beta_x_epsilonRecA::Union{AbstractArray, Nothing} = nothing + alif_beta_x_a::Union{AbstractArray, Nothing} = nothing # ---------------------------------------------------------------------------- # # Output Neurons # @@ -167,68 +182,43 @@ function kfn_1(params::Dict; device=cpu) slice[i] = randn()/10 # assign weight to synaptic connection end end - # project 3D w into 4D kfn.lif_wRec - kfn.lif_wRec = reshape(w, (row, col, n, 1)) .* ones(row, col, n, batch) |> device - - kfn.lif_zit = similar(kfn.lif_wRec) .= 0 |> device - kfn.lif_vt0 = zeros(1, 1, n, batch) |> device - kfn.lif_vt1 = zeros(1, 1, n, batch) |> device - kfn.lif_vth = ones(1, 1, n, batch) |> device - kfn.lif_vRest = zeros(1, 1, n, batch) |> device - # kfn.lif_zt0 = zeros(1, 1, n, batch) |> device - kfn.lif_zt1 = zeros(1, 1, n, batch) |> device - kfn.lif_refractoryCounter = zeros(1, 1, n, batch) |> device - kfn.lif_refractoryDuration = ones(1, 1, n, batch) .* 3 |> device + # project 3D w into 4D kfn.lif_wRec (row, col, n, batch) + kfn.lif_wRec = reshape(w, (row, col, n, 1)) .* ones(row, col, n, batch) |> device + kfn.lif_zit = similar(kfn.lif_wRec) .= 0 |> device + kfn.lif_vt0 = zeros(1, 1, n, batch) |> device + kfn.lif_vt1 = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_vth = similar(kfn.lif_vt0) .= 1 |> device + kfn.lif_vRest = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_zt0 = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_zt1 = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_refractoryCounter = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_refractoryDuration = similar(kfn.lif_vt0) .= 3 |> device kfn.lif_delta = 1.0 kfn.lif_tau_m = 20.0 - kfn.lif_alpha = ones(1, 1, n, batch) .* (exp(-kfn.lif_delta / kfn.lif_tau_m)) |> device - kfn.lif_phi = zeros(1, 1, n, batch) |> device - kfn.lif_epsilonRec = zeros(row, col, n, batch) |> device - # kfn.lif_eRec = zeros(row, col, n, batch) - kfn.lif_eta = zeros(1, 1, n, batch) |> device - kfn.lif_gammaPd = zeros(1, 1, n, batch) .* 0.3 |> device - kfn.lif_wRecChange = zeros(row, col, n, batch) |> device + kfn.lif_alpha = similar(kfn.lif_vt0) .= (exp(-kfn.lif_delta / kfn.lif_tau_m)) |> device + kfn.lif_phi = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_epsilonRec = similar(kfn.lif_wRec) .= 0 |> device + kfn.lif_eRec = similar(kfn.lif_wRec) .= 0 |> device + kfn.lif_eta = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_gammaPd = similar(kfn.lif_vt0) .= 0.3 |> device + kfn.lif_wRecChange = similar(kfn.lif_wRec) .= 0 |> device - kfn.lif_firingCounter = zeros(1, 1, n, batch) |> device - kfn.lif_arraySize = [row, col, n, batch] |> device - kfn.lif_arrayProjection3DTo4D = ones(row, col, n, batch) |> device + kfn.lif_firingCounter = similar(kfn.lif_vt0) .= 0 |> device - + kfn.lif_arrayProjection3DTo4D = similar(kfn.lif_wRec) .= 1 |> device + kfn.lif_recSignal = similar(kfn.lif_wRec) .= 0 |> device + kfn.lif_decayed_vt0 = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_decayed_epsilonRec = similar(kfn.lif_wRec) .= 0 |> device + kfn.lif_vt1_diff_vth = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_vt1_diff_vth_div_vth = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_gammaPd_div_vth = similar(kfn.lif_vt0) .= 0 |> device + kfn.lif_phiActivation = similar(kfn.lif_vt0) .= 0 |> device # ---------------------------------------------------------------------------- # # ALIF config # # ---------------------------------------------------------------------------- # n = kfn.params[:computeNeuron][:alif][:numbers][1] * kfn.params[:computeNeuron][:alif][:numbers][2] - kfn.alif_zit = zeros(row, col, n, batch) |> device - kfn.alif_vt0 = zeros(1, 1, n, batch) |> device - kfn.alif_vt1 = zeros(1, 1, n, batch) |> device - kfn.alif_vth = ones(1, 1, n, batch) |> device - kfn.alif_avth = ones(1, 1, n, batch) |> device - kfn.alif_vRest = zeros(1, 1, n, batch) |> device - # kfn.alif_zt0 = zeros(1, 1, n, batch) |> device - kfn.alif_zt1 = zeros(1, 1, n, batch) |> device - kfn.alif_refractoryCounter = zeros(1, 1, n, batch) |> device - kfn.alif_refractoryDuration = ones(1, 1, n, batch) .* 3 |> device - kfn.alif_delta = 1.0 - kfn.alif_tau_m = 20.0 - kfn.alif_alpha = ones(1, 1, n, batch) .* (exp(-kfn.alif_delta / kfn.alif_tau_m)) |> device - kfn.alif_phi = zeros(1, 1, n, batch) |> device - kfn.alif_epsilonRec = zeros(row, col, n, batch) |> device - kfn.alif_epsilonRecA = zeros(row, col, n, batch) |> device - # kfn.alif_eRec = zeros(row, col, n, batch) - kfn.alif_eta = zeros(1, 1, n, batch) |> device - kfn.alif_gammaPd = zeros(1, 1, n, batch) .* 0.3 |> device - kfn.alif_wRecChange = zeros(row, col, n, batch) |> device - - kfn.alif_a = zeros(1, 1, n, batch) |> device - kfn.alif_beta = zeros(1, 1, n, batch) .* 0.15 |> device - kfn.alif_tau_a = 100.0 - kfn.alif_rho = zeros(1, 1, n, batch) .* (exp(-kfn.alif_delta / kfn.alif_tau_a)) |> device - - kfn.alif_firingCounter = zeros(1, 1, n, batch) |> device - kfn.alif_arraySize = [row, col, n, batch] |> device - kfn.alif_arrayProjection3DTo4D = ones(row, col, n, batch) |> device # subscription w = zeros(row, col, n) @@ -241,8 +231,49 @@ function kfn_1(params::Dict; device=cpu) end end # project 3D w into 4D kfn.alif_wRec - kfn.alif_wRec = reshape(w, (row, col, n, 1)) .* ones(row, col, n, batch) |> device - + kfn.alif_wRec = reshape(w, (row, col, n, 1)) .* ones(row, col, n, batch) |> device + kfn.alif_zit = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_vt0 = zeros(1, 1, n, batch) |> device + kfn.alif_vt1 = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_vth = similar(kfn.alif_vt0) .= 1 |> device + kfn.alif_vRest = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_zt0 = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_zt1 = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_refractoryCounter = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_refractoryDuration = similar(kfn.alif_vt0) .= 3 |> device + kfn.alif_delta = 1.0 + kfn.alif_tau_m = 20.0 + kfn.alif_alpha = similar(kfn.alif_vt0) .= (exp(-kfn.alif_delta / kfn.alif_tau_m)) |> device + kfn.alif_phi = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_epsilonRec = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_eRec = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_eta = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_gammaPd = similar(kfn.alif_vt0) .= 0.3 |> device + kfn.alif_wRecChange = similar(kfn.alif_wRec) .= 0 |> device + + kfn.alif_firingCounter = similar(kfn.alif_vt0) .= 0 |> device + + kfn.alif_arrayProjection3DTo4D = similar(kfn.alif_wRec) .= 1 |> device + kfn.alif_recSignal = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_decayed_vt0 = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_decayed_epsilonRec = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_vt1_diff_vth = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_vt1_diff_vth_div_vth = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_gammaPd_div_vth = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_phiActivation = similar(kfn.alif_vt0) .= 0 |> device + + # alif specific variables + kfn.alif_epsilonRecA = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_avth = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_a = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_beta = similar(kfn.alif_vt0) .= 0.07 |> device + kfn.alif_tau_a = 100.0 + kfn.alif_rho = similar(kfn.alif_vt0) .= (exp(-kfn.alif_delta / kfn.alif_tau_a)) |> device + kfn.alif_phi_x_epsilonRec = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_phi_x_beta = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_rho_diff_phi_x_beta = similar(kfn.alif_vt0) .= 0 |> device + kfn.alif_rho_div_phi_x_beta_x_epsilonRecA = similar(kfn.alif_wRec) .= 0 |> device + kfn.alif_beta_x_a = similar(kfn.alif_vt0) .= 0 |> device # ---------------------------------------------------------------------------- # # output config #