module forward # export using Flux, CUDA using GeneralUtils using ..type, ..snnUtil #------------------------------------------------------------------------------------------------100 """ kfn forward input (row, col, batch) """ function (kfn::kfn_1)(input::AbstractArray) kfn.timeStep .+= 1 #TODO time step forward if view(kfn.learningStage, 1)[1] == 1 # reset learning params # kfn.learningStage = [2] end # println(">>> input ", size(input)) # println(">>> zit ", size(kfn.zit)) # println(">>> lif_zit ", size(kfn.lif_zit)) # println(">>> lif_recSignal ", size(kfn.lif_recSignal)) # println(">>> lif_wRec ", size(kfn.lif_wRec)) # println(">>> lif_refractoryCounter ", size(kfn.lif_refractoryCounter)) # println(">>> lif_alpha ", size(kfn.lif_alpha)) # println(">>> lif_vt0 ", size(kfn.lif_vt0)) # println(">>> lif_vt0 sum ", sum(kfn.lif_vt0)) # pass input_data into input neuron. GeneralUtils.cartesianAssign!(kfn.zit, input) lifForward( kfn.zit, kfn.lif_zit, kfn.lif_wRec, kfn.lif_vt0, kfn.lif_vt1, kfn.lif_vth, kfn.lif_vRest, kfn.lif_zt1, kfn.lif_alpha, kfn.lif_phi, kfn.lif_epsilonRec, kfn.lif_refractoryCounter, kfn.lif_refractoryDuration, kfn.lif_gammaPd, kfn.lif_firingCounter, kfn.lif_arraySize, kfn.lif_arrayProjection3DTo4D) 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) # error("DEBUG -> kfn forward") # update activation matrix by concatenate (input, lif_zt1, alif_zt1) to form activation matrix _zit = cat(reshape(input, (size(input, 1), size(input, 2), 1, size(input, 3))), reshape(kfn.lif_zt1, (size(input, 1), :, 1, size(input, 3))), reshape(kfn.alif_zt1, (size(input, 1), :, 1, size(input, 3))), dims=2) kfn.zit .= reshape(_zit, (size(input, 1), :, size(input, 3))) # read out onForward( kfn.zit, kfn.on_zit, kfn.on_wOut, kfn.on_vt0, kfn.on_vt1, kfn.on_vth, kfn.on_vRest, kfn.on_zt1, kfn.on_alpha, kfn.on_phi, kfn.on_epsilonRec, kfn.on_refractoryCounter, kfn.on_refractoryDuration, kfn.on_gammaPd, kfn.on_firingCounter) return reshape(kfn.on_zt1, (size(input, 1), :)), kfn.zit end function lifForward(kfn_zit, zit, wRec, vt0, vt1, vth, vRest, zt1, alpha, phi, epsilonRec, refractoryCounter, 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 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, vt0, vt1, vth, vRest, zt1, alpha, phi, epsilonRec, refractoryCounter, refractoryDuration, gammaPd, firingCounter) d1, d2, d3, d4 = size(wOut) zit .= reshape(kfn_zit, (d1, d2, 1, d4)) .* ones(size(wOut)...) # 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 # neuron is inactive (in refractory period) 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 # neuron is active view(vt1, :, :, i, j)[1] = (view(alpha, :, :, i, j)[1] * view(vt0,:, :, i, j)[1]) + sum(view(zit, :, :, i, j) .* view(wOut, :, :, 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 # function onForward(kfn_zit, # zit, # wOut, # vt0, # vt1, # vth, # vRest, # zt1, # alpha, # phi, # epsilonRec, # refractoryCounter, # refractoryDuration, # gammaPd, # firingCounter) # d1, d2, d3, d4 = size(wOut) # zit .= reshape(kfn_zit, (d1, d2, 1, d4)) .* ones(size(wOut)...) # 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 # neuron is inactive (in refractory period) # 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 # neuron is active # view(vt1, :, :, i, j)[1] = # (view(alpha, :, :, i, j)[1] * view(vt0,:, :, i, j)[1]) + # sum(view(zit, :, :, i, j) .* view(wOut, :, :, 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 end # module