From 95cad151dc4a7c05e65bbeb789fafca74b8ca0f3 Mon Sep 17 00:00:00 2001 From: tonaerospace Date: Wed, 17 May 2023 15:08:14 +0700 Subject: [PATCH] refractoring --- src/forward.jl | 16 +++--- src/learn.jl | 14 ++--- src/snn_utils.jl | 42 +++++++-------- src/types.jl | 136 +++++++++++++++++++++++------------------------ 4 files changed, 104 insertions(+), 104 deletions(-) diff --git a/src/forward.jl b/src/forward.jl index 31116b8..8e62121 100644 --- a/src/forward.jl +++ b/src/forward.jl @@ -99,18 +99,18 @@ end #------------------------------------------------------------------------------------------------100 -""" passthrough_neuron forward() +""" passthroughNeuron forward() """ -function (n::passthrough_neuron)(kfn::knowledgeFn) +function (n::passthroughNeuron)(kfn::knowledgeFn) n.timeStep = kfn.timeStep # n.global_tick = kfn.global_tick end #------------------------------------------------------------------------------------------------100 -""" lif_neuron forward() +""" lifNeuron forward() """ -function (n::lif_neuron)(kfn::knowledgeFn) +function (n::lifNeuron)(kfn::knowledgeFn) n.timeStep = kfn.timeStep # pulling other neuron's firing status at time t @@ -151,9 +151,9 @@ end #------------------------------------------------------------------------------------------------100 -""" alif_neuron forward() +""" alifNeuron forward() """ -function (n::alif_neuron)(kfn::knowledgeFn) +function (n::alifNeuron)(kfn::knowledgeFn) n.timeStep = kfn.timeStep n.z_i_t = getindex(kfn.firedNeurons_t0, n.subscriptionList) @@ -197,10 +197,10 @@ end #------------------------------------------------------------------------------------------------100 -""" linear_neuron forward() +""" linearNeuron forward() In this implementation, each output neuron is fully connected to every lif and alif neuron. """ -function (n::linear_neuron)(kfn::T) where T<:knowledgeFn +function (n::linearNeuron)(kfn::T) where T<:knowledgeFn n.timeStep = kfn.timeStep # pulling other neuron's firing status at time t diff --git a/src/learn.jl b/src/learn.jl index 507f2d4..ef0bea8 100644 --- a/src/learn.jl +++ b/src/learn.jl @@ -82,15 +82,15 @@ function learn!(kfn::kfn_1, correctAnswer::AbstractVector) end end -""" passthrough_neuron learn() +""" passthroughNeuron learn() """ -function learn!(n::passthrough_neuron, kfn::knowledgeFn) +function learn!(n::passthroughNeuron, kfn::knowledgeFn) # skip end """ lif learn() """ -function learn!(n::lif_neuron, error::Number) +function learn!(n::lifNeuron, error::Number) n.eRec = n.phi * n.epsilonRec ΔwRecChange = n.eta * error * n.eRec @@ -98,9 +98,9 @@ function learn!(n::lif_neuron, error::Number) reset_epsilonRec!(n) end -""" alif_neuron learn() +""" alifNeuron learn() """ -function learn!(n::alif_neuron, error::Number) +function learn!(n::alifNeuron, error::Number) n.eRec_v = n.phi * n.epsilonRec n.eRec_a = -n.phi * n.beta * n.epsilonRecA n.eRec = n.eRec_v + n.eRec_a @@ -111,9 +111,9 @@ function learn!(n::alif_neuron, error::Number) reset_epsilonRecA!(n) end -""" linear_neuron learn() +""" linearNeuron learn() """ -function learn!(n::linear_neuron, error::Number) +function learn!(n::linearNeuron, error::Number) n.eRec = n.phi * n.epsilonRec ΔwRecChange = n.eta * error * n.eRec diff --git a/src/snn_utils.jl b/src/snn_utils.jl index 238f65c..d9d7011 100644 --- a/src/snn_utils.jl +++ b/src/snn_utils.jl @@ -15,7 +15,7 @@ using ..types #------------------------------------------------------------------------------------------------100 -function timestep_forward!(x::passthrough_neuron) +function timestep_forward!(x::passthroughNeuron) x.z_t = x.z_t1 end @@ -34,30 +34,30 @@ reset_v_t!(n::neuron) = n.v_t = n.vRest reset_z_t!(n::computeNeuron) = n.z_t = false reset_epsilonRec!(n::computeNeuron) = n.epsilonRec = n.epsilonRec * 0.0 reset_epsilonRec!(n::outputNeuron) = n.epsilonRec = n.epsilonRec * 0.0 -reset_epsilonRecA!(n::alif_neuron) = n.epsilonRecA = n.epsilonRecA * 0.0 +reset_epsilonRecA!(n::alifNeuron) = n.epsilonRecA = n.epsilonRecA * 0.0 reset_epsilon_in!(n::computeNeuron) = n.epsilon_in = isnothing(n.epsilon_in) ? nothing : n.epsilon_in * 0.0 -reset_error!(n::Union{computeNeuron, linear_neuron}) = n.error = nothing +reset_error!(n::Union{computeNeuron, linearNeuron}) = n.error = nothing reset_w_in_change!(n::computeNeuron) = n.w_in_change = isnothing(n.w_in_change) ? nothing : n.w_in_change * 0.0 reset_wRecChange!(n::Union{computeNeuron, outputNeuron}) = n.wRecChange = n.wRecChange * 0.0 -reset_a!(n::alif_neuron) = n.a = n.a * 0.0 +reset_a!(n::alifNeuron) = n.a = n.a * 0.0 reset_reg_voltage_a!(n::computeNeuron) = n.reg_voltage_a = n.reg_voltage_a * 0.0 reset_reg_voltage_b!(n::computeNeuron) = n.reg_voltage_b = n.reg_voltage_b * 0.0 reset_reg_voltage_error!(n::computeNeuron) = n.reg_voltage_error = n.reg_voltage_error * 0.0 -reset_firing_counter!(n::computeNeuron) = n.firingCounter = n.firingCounter * 0.0 -reset_firing_diff!(n::Union{computeNeuron, linear_neuron}) = n.firingDiff = n.firingDiff * 0.0 -reset_refractoryCounter!(n::Union{computeNeuron, linear_neuron}) = n.refractoryCounter = n.refractoryCounter * 0.0 +reset_firing_counter!(n::Union{computeNeuron, outputNeuron}) = n.firingCounter = n.firingCounter * 0.0 +reset_firing_diff!(n::Union{computeNeuron, linearNeuron}) = n.firingDiff = n.firingDiff * 0.0 +reset_refractoryCounter!(n::Union{computeNeuron, outputNeuron}) = n.refractoryCounter = n.refractoryCounter * 0.0 # reset function for output neuron -reset_epsilon_j!(n::linear_neuron) = n.epsilon_j = n.epsilon_j * 0.0 -reset_out_t!(n::linear_neuron) = n.out_t = n.out_t * 0.0 -reset_w_out_change!(n::linear_neuron) = n.w_out_change = n.w_out_change * 0.0 -reset_b_change!(n::linear_neuron) = n.b_change = n.b_change * 0.0 +reset_epsilon_j!(n::linearNeuron) = n.epsilon_j = n.epsilon_j * 0.0 +reset_out_t!(n::linearNeuron) = n.out_t = n.out_t * 0.0 +reset_w_out_change!(n::linearNeuron) = n.w_out_change = n.w_out_change * 0.0 +reset_b_change!(n::linearNeuron) = n.b_change = n.b_change * 0.0 """ Reset a part of learning-related params that used to collect learning history during learning session """ -# function reset_learning_no_wchange!(n::lif_neuron) +# function reset_learning_no_wchange!(n::lifNeuron) # reset_epsilonRec!(n) # # reset_v_t!(n) # # reset_z_t!(n) @@ -73,7 +73,7 @@ reset_b_change!(n::linear_neuron) = n.b_change = n.b_change * 0.0 # # # it will stay in refractory state forever # # reset_refractory_state_active!(n) # end -# function reset_learning_no_wchange!(n::Union{alif_neuron, elif_neuron}) +# function reset_learning_no_wchange!(n::Union{alifNeuron, elif_neuron}) # reset_epsilonRec!(n) # reset_epsilonRecA!(n) # reset_v_t!(n) @@ -91,7 +91,7 @@ reset_b_change!(n::linear_neuron) = n.b_change = n.b_change * 0.0 # # it will stay in refractory state forever # reset_refractory_state_active!(n) # end -# function reset_learning_no_wchange!(n::linear_neuron) +# function reset_learning_no_wchange!(n::linearNeuron) # reset_epsilon_j!(n) # reset_out_t!(n) # reset_error!(n) @@ -99,7 +99,7 @@ reset_b_change!(n::linear_neuron) = n.b_change = n.b_change * 0.0 """ Reset all learning-related params at the END of learning session """ -function resetLearningParams!(n::lif_neuron) +function resetLearningParams!(n::lifNeuron) reset_epsilonRec!(n) reset_wRecChange!(n) # reset_v_t!(n) @@ -111,7 +111,7 @@ function resetLearningParams!(n::lif_neuron) # refractory state, it will stay in refractory state forever reset_refractoryCounter!(n) end -function resetLearningParams!(n::alif_neuron) +function resetLearningParams!(n::alifNeuron) reset_epsilonRec!(n) reset_epsilonRecA!(n) reset_wRecChange!(n) @@ -126,14 +126,14 @@ function resetLearningParams!(n::alif_neuron) reset_refractoryCounter!(n) end -# function reset_learning_no_wchange!(n::passthrough_neuron) +# function reset_learning_no_wchange!(n::passthroughNeuron) # end -function resetLearningParams!(n::passthrough_neuron) +function resetLearningParams!(n::passthroughNeuron) # skip end -function resetLearningParams!(n::linear_neuron) +function resetLearningParams!(n::linearNeuron) reset_epsilonRec!(n) reset_wRecChange!(n) reset_v_t!(n) @@ -196,7 +196,7 @@ end """ Regulates membrane potential to stay under v_th, output is weight change """ -function cal_v_reg!(n::lif_neuron) +function cal_v_reg!(n::lifNeuron) # retified linear function component_a1 = n.v_t1 - n.v_th < 0 ? 0 : (n.v_t1 - n.v_th)^2 component_a2 = -n.v_t1 - n.v_th < 0 ? 0 : (-n.v_t1 - n.v_th)^2 @@ -207,7 +207,7 @@ function cal_v_reg!(n::lif_neuron) n.reg_voltage_b = n.reg_voltage_b + (component_b * n.epsilonRec) end -function cal_v_reg!(n::alif_neuron) +function cal_v_reg!(n::alifNeuron) # retified linear function component_a1 = n.v_t1 - n.av_th < 0 ? 0 : (n.v_t1 - n.av_th)^2 component_a2 = -n.v_t1 - n.av_th < 0 ? 0 : (-n.v_t1 - n.av_th)^2 diff --git a/src/types.jl b/src/types.jl index 559b531..eb3ecef 100644 --- a/src/types.jl +++ b/src/types.jl @@ -2,8 +2,8 @@ module types export # struct - IronpenStruct, model, knowledgeFn, lif_neuron, alif_neuron, linear_neuron, - kfn_1, inputNeuron, computeNeuron, neuron, outputNeuron, passthrough_neuron, + IronpenStruct, model, knowledgeFn, lifNeuron, alifNeuron, linearNeuron, + kfn_1, inputNeuron, computeNeuron, neuron, outputNeuron, passthroughNeuron, # function instantiate_custom_types, init_neuron, populate_neuron, @@ -42,7 +42,7 @@ end # Example I_kfnparams = Dict( - :type => "lif_neuron", + :type => "lifNeuron", :v_t1 => 0.0, # neuron membrane potential at time = t+1 :v_th => 2.0, # neuron firing threshold (this value is treated as maximum bound if I use auto generate) :z_t => false, # neuron firing status at time = t @@ -120,7 +120,7 @@ end # Example lif_neuron_params = Dict( - :type => "lif_neuron", + :type => "lifNeuron", :v_th => 1.2, # neuron firing threshold (this value is treated as maximum bound if I use auto generate) :z_t => false, # neuron firing status at time = t :gammaPd => 0.3, # discount factor. The value is from the paper @@ -130,7 +130,7 @@ end ) alif_neuron_params = Dict( - :type => "alif_neuron", + :type => "alifNeuron", :v_th => 1.2, # neuron firing threshold (this value is treated as maximum bound if I use auto generate) :z_t => false, # neuron firing status at time = t :gammaPd => 0.3, # discount factor. The value is from the paper @@ -146,7 +146,7 @@ end ) linear_neuron_params = Dict( - :type => "linear_neuron", + :type => "linearNeuron", :k => 0.9, # output leakink coefficient :tau_out => 5.0, # output time constant in millisecond. It should equals to time use for 1 sequence :out => 0.0, # neuron's output value store here @@ -166,7 +166,7 @@ end :neuron_w_rec_generation_pattern => "random", :neuron_v_t_default => 0.5, :neuron_voltage_drop_percentage => "100%", - :neuron_firing_rate_target => 50.0, + :neuronFiringRateTarget => 50.0, :neuron_learning_rate => 0.01, :neuron_c_reg => 0.0001, :neuron_c_reg_v => 0.0001, @@ -182,23 +182,23 @@ function kfn_1(kfnParams::Dict) kfn.kfnParams = kfnParams kfn.knowledgeFnName = kfn.kfnParams[:knowledgeFnName] - if kfn.kfnParams[:compute_neuron_number] < kfn.kfnParams[:total_input_port] + if kfn.kfnParams[:computeNeuronNumber] < kfn.kfnParams[:totalInputPort] throw(error("number of compute neuron must be greater than input neuron")) end # Bn if kfn.kfnParams[:Bn] == "random" - kfn.Bn = [Random.rand(0:0.001:1) for i in 1:kfn.kfnParams[:compute_neuron_number]] + kfn.Bn = [Random.rand(0:0.001:1) for i in 1:kfn.kfnParams[:computeNeuronNumber]] else # in case I want to specify manually - kfn.Bn = [kfn.kfnParams[:Bn] for i in 1:kfn.kfnParams[:compute_neuron_number]] + kfn.Bn = [kfn.kfnParams[:Bn] for i in 1:kfn.kfnParams[:computeNeuronNumber]] end # assign neurons ID by their position in kfn.neurons array because I think it is # straight forward way # add input port - for (k, v) in kfn.kfnParams[:input_port] - current_type = kfn.kfnParams[:input_port][k] + for (k, v) in kfn.kfnParams[:inputPort] + current_type = kfn.kfnParams[:inputPort][k] for i = 1:current_type[:numbers] n_id = length(kfn.neuronsArray) + 1 neuron = init_neuron(n_id, current_type[:params], kfn.kfnParams) @@ -216,22 +216,22 @@ function kfn_1(kfnParams::Dict) end end - for i = 1:kfn.kfnParams[:output_port][:numbers] - neuron = init_neuron(i, kfn.kfnParams[:output_port][:params], + for i = 1:kfn.kfnParams[:outputPort][:numbers] + neuron = init_neuron(i, kfn.kfnParams[:outputPort][:params], kfn.kfnParams) push!(kfn.outputNeuronsArray, neuron) end for n in kfn.neuronsArray if typeof(n) <: computeNeuron - n.firingRateTarget = kfn.kfnParams[:neuron_firing_rate_target] + n.firingRateTarget = kfn.kfnParams[:neuronFiringRateTarget] end end # excitatory neuron to inhabitory neuron = 60:40 % of computeNeuron - ex_number = Int(floor(0.6 * kfn.kfnParams[:compute_neuron_number])) + ex_number = Int(floor(0.6 * kfn.kfnParams[:computeNeuronNumber])) ex_n = [1 for i in 1:ex_number] - in_number = kfn.kfnParams[:compute_neuron_number] - ex_number + in_number = kfn.kfnParams[:computeNeuronNumber] - ex_number in_n = [-1 for i in 1:in_number] ex_in = shuffle!([ex_n; in_n]) @@ -268,11 +268,11 @@ end #------------------------------------------------------------------------------------------------100 -""" passthrough_neuron struct +""" passthroughNeuron struct """ -Base.@kwdef mutable struct passthrough_neuron <: inputNeuron +Base.@kwdef mutable struct passthroughNeuron <: inputNeuron id::Union{Int64,Nothing} = nothing # ID of this neuron which is it position in knowledgeFn array - type::String = "passthrough_neuron" + type::String = "passthroughNeuron" knowledgeFnName::Union{String,Nothing} = nothing # knowledgeFn that this neuron belongs to z_t::Bool = false z_t1::Bool = false @@ -280,8 +280,8 @@ Base.@kwdef mutable struct passthrough_neuron <: inputNeuron ExInType::Integer = 1 # 1 excitatory, -1 inhabitory. input neuron is always excitatory end -function passthrough_neuron(params::Dict) - n = passthrough_neuron() +function passthroughNeuron(params::Dict) + n = passthroughNeuron() field_names = fieldnames(typeof(n)) for i in field_names if i in keys(params) @@ -298,11 +298,11 @@ end #------------------------------------------------------------------------------------------------100 -""" lif_neuron struct +""" lifNeuron struct """ -Base.@kwdef mutable struct lif_neuron <: computeNeuron +Base.@kwdef mutable struct lifNeuron <: computeNeuron id::Union{Int64,Nothing} = nothing # this neuron ID i.e. position of this neuron in knowledgeFn - type::String = "lif_neuron" + type::String = "lifNeuron" ExInType::Integer = 1 # 1 excitatory, -1 inhabitory # Bn::Union{Float64,Nothing} = Random.rand() # Bias for neuron error knowledgeFnName::Union{String,Nothing} = nothing # knowledgeFn that this neuron belongs to @@ -361,7 +361,7 @@ end # Example lif_neuron_params = Dict( - :type => "lif_neuron", + :type => "lifNeuron", :v_th => 1.2, # neuron firing threshold (this value is treated as maximum bound if I use auto generate) :z_t => false, # neuron firing status at time = t :gammaPd => 0.3, # discount factor. The value is from the paper @@ -370,10 +370,10 @@ end :tau_m => 5.0, # membrane time constant in millisecond. It should equals to time use for 1 sequence ) - neuron1 = lif_neuron(lif_neuron_params) + neuron1 = lifNeuron(lif_neuron_params) """ -function lif_neuron(params::Dict) - n = lif_neuron() +function lifNeuron(params::Dict) + n = lifNeuron() field_names = fieldnames(typeof(n)) for i in field_names if i in keys(params) @@ -390,11 +390,11 @@ end #------------------------------------------------------------------------------------------------100 -""" alif_neuron struct +""" alifNeuron struct """ -Base.@kwdef mutable struct alif_neuron <: computeNeuron +Base.@kwdef mutable struct alifNeuron <: computeNeuron id::Union{Int64,Nothing} = nothing # this neuron ID i.e. position of this neuron in knowledgeFn - type::String = "alif_neuron" + type::String = "alifNeuron" ExInType::Integer = -1 # 1 excitatory, -1 inhabitory # Bn::Union{Float64,Nothing} = Random.rand() # Bias for neuron error knowledgeFnName::Union{String,Nothing} = nothing # knowledgeFn that this neuron belongs to @@ -462,7 +462,7 @@ end # Example alif_neuron_params = Dict( - :type => "alif_neuron", + :type => "alifNeuron", :v_th => 1.2, # neuron firing threshold (this value is treated as maximum bound if I use auto generate) :z_t => false, # neuron firing status at time = t @@ -479,10 +479,10 @@ end :a => 0.0, ) - neuron1 = alif_neuron(alif_neuron_params) + neuron1 = alifNeuron(alif_neuron_params) """ -function alif_neuron(params::Dict) - n = alif_neuron() +function alifNeuron(params::Dict) + n = alifNeuron() field_names = fieldnames(typeof(n)) for i in field_names if i in keys(params) @@ -498,11 +498,11 @@ function alif_neuron(params::Dict) end #------------------------------------------------------------------------------------------------100 -""" linear_neuron struct +""" linearNeuron struct """ -Base.@kwdef mutable struct linear_neuron <: outputNeuron +Base.@kwdef mutable struct linearNeuron <: outputNeuron id::Union{Int64,Nothing} = nothing # ID of this neuron which is it position in knowledgeFn array - type::String = "linear_neuron" + type::String = "linearNeuron" knowledgeFnName::Union{String,Nothing} = nothing # knowledgeFn that this neuron belongs to subscriptionList::Union{Array{Int64},Nothing} = nothing # list of other neuron that this neuron synapse subscribed to timeStep::Union{Number,Nothing} = nothing # current time @@ -549,16 +549,16 @@ end # Example linear_neuron_params = Dict( - :type => "linear_neuron", + :type => "linearNeuron", :k => 0.9, # output leakink coefficient :tau_out => 5.0, # output time constant in millisecond. It should equals to time use for 1 sequence :out => 0.0, # neuron's output value store here ) - neuron1 = linear_neuron(linear_neuron_params) + neuron1 = linearNeuron(linear_neuron_params) """ -function linear_neuron(params::Dict) - n = linear_neuron() +function linearNeuron(params::Dict) + n = linearNeuron() field_names = fieldnames(typeof(n)) for i in field_names if i in keys(params) @@ -592,15 +592,15 @@ function load_optimiser(optimiser_name::String; params::Union{Dict,Nothing} = no end end -function init_neuron!(id::Int64, n::passthrough_neuron, n_params::Dict, kfnParams::Dict) +function init_neuron!(id::Int64, n::passthroughNeuron, n_params::Dict, kfnParams::Dict) n.id = id n.knowledgeFnName = kfnParams[:knowledgeFnName] end -# function init_neuron!(id::Int64, n::lif_neuron, kfnParams::Dict) +# function init_neuron!(id::Int64, n::lifNeuron, kfnParams::Dict) # n.id = id # n.knowledgeFnName = kfnParams[:knowledgeFnName] -# subscription_options = shuffle!([1:(kfnParams[:input_neuron_number]+kfnParams[:compute_neuron_number])...]) +# subscription_options = shuffle!([1:(kfnParams[:input_neuron_number]+kfnParams[:computeNeuronNumber])...]) # if typeof(kfnParams[:synaptic_connection_number]) == String # percent = parse(Int, kfnParams[:synaptic_connection_number][1:end-1]) / 100 # synaptic_connection_number = floor(length(subscription_options) * percent) @@ -614,12 +614,12 @@ end # n.alpha = calculate_α(n) # end -function init_neuron!(id::Int64, n::lif_neuron, n_params::Dict, kfnParams::Dict) +function init_neuron!(id::Int64, n::lifNeuron, n_params::Dict, kfnParams::Dict) n.id = id n.knowledgeFnName = kfnParams[:knowledgeFnName] - subscription_options = shuffle!([1:kfnParams[:total_neurons]...]) + subscription_options = shuffle!([1:kfnParams[:totalNeurons]...]) subscription_numbers = Int(floor(n_params[:synaptic_connection_number] * - kfnParams[:total_neurons] / 100.0)) + kfnParams[:totalNeurons] / 100.0)) n.subscriptionList = [pop!(subscription_options) for i = 1:subscription_numbers] # prevent subscription to itself by removing this neuron id @@ -632,13 +632,13 @@ function init_neuron!(id::Int64, n::lif_neuron, n_params::Dict, kfnParams::Dict) n.alpha = calculate_α(n) end -function init_neuron!(id::Int64, n::alif_neuron, n_params::Dict, +function init_neuron!(id::Int64, n::alifNeuron, n_params::Dict, kfnParams::Dict) n.id = id n.knowledgeFnName = kfnParams[:knowledgeFnName] - subscription_options = shuffle!([1:kfnParams[:total_neurons]...]) + subscription_options = shuffle!([1:kfnParams[:totalNeurons]...]) subscription_numbers = Int(floor(n_params[:synaptic_connection_number] * - kfnParams[:total_neurons] / 100.0)) + kfnParams[:totalNeurons] / 100.0)) n.subscriptionList = [pop!(subscription_options) for i = 1:subscription_numbers] # prevent subscription to itself by removing this neuron id @@ -657,13 +657,13 @@ function init_neuron!(id::Int64, n::alif_neuron, n_params::Dict, end -function init_neuron!(id::Int64, n::linear_neuron, n_params::Dict, kfnParams::Dict) +function init_neuron!(id::Int64, n::linearNeuron, n_params::Dict, kfnParams::Dict) n.id = id n.knowledgeFnName = kfnParams[:knowledgeFnName] - subscription_options = shuffle!([kfnParams[:total_input_port]+1 : kfnParams[:total_neurons]...]) + subscription_options = shuffle!([kfnParams[:totalInputPort]+1 : kfnParams[:totalNeurons]...]) subscription_numbers = Int(floor(n_params[:synaptic_connection_number] * - kfnParams[:total_compute_neuron] / 100.0)) + kfnParams[:totalComputeNeuron] / 100.0)) n.subscriptionList = [pop!(subscription_options) for i = 1:subscription_numbers] n.synapticStrength = rand(-5:0.1:-3, length(n.subscriptionList)) @@ -695,14 +695,14 @@ function instantiate_custom_types(params::Union{Dict,Nothing} = nothing) return model() elseif type == "knowledgeFn" return knowledgeFn() - elseif type == "passthrough_neuron" - return passthrough_neuron(params) - elseif type == "lif_neuron" - return lif_neuron(params) - elseif type == "alif_neuron" - return alif_neuron(params) - elseif type == "linear_neuron" - return linear_neuron(params) + elseif type == "passthroughNeuron" + return passthroughNeuron(params) + elseif type == "lifNeuron" + return lifNeuron(params) + elseif type == "alifNeuron" + return alifNeuron(params) + elseif type == "linearNeuron" + return linearNeuron(params) else return nothing end @@ -716,17 +716,17 @@ end # function add_neuron!(neuron_Dict::Dict, kfn::knowledgeFn) # id = length(kfn.neuronsArray) + 1 # neuron = init_neuron(id, neuron_Dict, kfn.kfnParams, -# total_neurons = (length(kfn.neuronsArray) + 1)) +# totalNeurons = (length(kfn.neuronsArray) + 1)) # push!(kfn.neuronsArray, neuron) # # Randomly select an output neuron to add a new neuron to # add_n_output_n!(Random.rand(kfn.outputNeuronsArray), id) # end -calculate_α(neuron::lif_neuron) = exp(-neuron.delta / neuron.tau_m) -calculate_α(neuron::alif_neuron) = exp(-neuron.delta / neuron.tau_m) -calculate_ρ(neuron::alif_neuron) = exp(-neuron.delta / neuron.tau_a) -calculate_k(neuron::linear_neuron) = exp(-neuron.delta / neuron.tau_out) +calculate_α(neuron::lifNeuron) = exp(-neuron.delta / neuron.tau_m) +calculate_α(neuron::alifNeuron) = exp(-neuron.delta / neuron.tau_m) +calculate_ρ(neuron::alifNeuron) = exp(-neuron.delta / neuron.tau_a) +calculate_k(neuron::linearNeuron) = exp(-neuron.delta / neuron.tau_out) #------------------------------------------------------------------------------------------------100