Neuron models

There is a number of predefined models which can be used with the ModelSpec::addNeuronPopulationpygenn.GeNNModel.add_neuron_population method:

• NeuronModels::Izhikevich
• NeuronModels::IzhikevichVariable
• NeuronModels::LIF
• NeuronModels::Poisson
• NeuronModels::PoissonNew
• NeuronModels::RulkovMap
• NeuronModels::SpikeSource
• NeuronModels::SpikeSourceArray
• NeuronModels::TraubMiles
• NeuronModels::TraubMilesAlt
• NeuronModels::TraubMilesFast
• NeuronModels::TraubMilesNStep

In Python, these models can be selected by their unqualified name e.g. "Izhikevich".

Example usage:

// Izhikevich model parameters - tonic spiking
NeuronModels::Izhikevich::ParamValues izh_p(
    0.02,       // 0 - a
    0.2,        // 1 - b
    -65,        // 2 - c
    6           // 3 - d
); 

// Izhikevich model initial conditions - tonic spiking
NeuronModels::Izhikevich::VarValues izh_ini(
    -65,        // 0 - V
    -20         // 1 - U
);
    
model.addNeuronPopulation<NeuronModels::Izhikevich>("Izh1", 10, izh_p, izh_ini);

# Izhikevich model parameters - tonic spiking
izh_p= {
    "a": 0.02,
    "b": 0.2,
    "c": -65.0,
    "d": 6.0
}

# Izhikevich model initial conditions - tonic spiking
izh_ini= {
    "V": -65.0,
    "U": -20.0
}
     
pop1= model.add_neuron_population("pop1", 10, "Izhikevich", izh_p, izh_ini) 

Defining your own neuron type

In order to define a new neuron type for use in a GeNN application, it is necessary to define a new class derived from NeuronModels::Base. For convenience, the methods this class should implement can be implemented using macrosthis can be done using the pygenn.genn_model.create_custom_neuron_class function with the following basic keyword arguments:

• DECLARE_MODEL(TYPE, NUM_PARAMS, NUM_VARS): declared the boilerplate code required for the model e.g. the correct specialisations of NewModels::ValueBase used to wrap the neuron model parameters and values class_name: the name of the new model .
• SET_SIM_CODE(SIM_CODE)sim_code=SIM_CODE : where SIM_CODE contains the code for executing the integration of the model for one time stepWithin this code string, variables need to be referred to by $(NAME), where NAME is the name of the variable as defined in the vector varNames. The code may refer to the predefined primitives DT for the time step size and $(Isyn) for the total incoming synaptic current. It can also refer to a unique ID (within the population) using $(id).
• SET_THRESHOLD_CONDITION_CODE(THRESHOLD_CONDITION_CODE)threshold_condition_code=THRESHOLD_CONDITION_CODE defines the condition for true spike detection.
• SET_RESET_CODE(RESET_CODE)reset_code=RESET_CODE defines code to be run after a true spike is emitted.
• SET_PARAM_NAMES()param_names defines the names of the model parameters. If defined as NAME here, they can then be referenced as $(NAME) in the code string.
  The length of this list should match the NUM_PARAM specified in DECLARE_MODEL.
  Parameters are assumed to be always of type double.
• SET_VARS()var_name_types defines the names, type strings (e.g. "float", "double", etc) and (optionally) access mode of the neuron state variables. The type string "scalar" can be used for variables which should be implemented using the precision set globally for the model with ModelSpec::setPrecision from pygenn.GeNNModel.__init__ . The variables defined here as NAME can then be used in the syntax $(NAME) in the code string. If the access mode is set to VarAccess::READ_ONLY VarAccess_READ_ONLY , GeNN applies additional optimisations and models should not write to it. By default such read-only variables are shared across all batches (see section Batching). If, instead, a read-only variable should be duplicated across batches, its access mode should be set to VarAccess::READ_ONLY_DUPLICATE VarAccess_READ_ONLY_DUPLICATE .
• SET_NEEDS_AUTO_REFRACTORY() is_auto_refractory_required defines whether the neuron should include an automatic refractory period to prevent it emitting spikes in successive timesteps.

For example, we can define a leaky integrator solved using Euler's method:

class LeakyIntegrator : public NeuronModels::Base
{
public:
    DECLARE_MODEL(LeakyIntegrator, 1, 1);
    
    SET_SIM_CODE("$(V)+= (-$(V)+$(Isyn))*(DT/$(tau));");
    SET_THRESHOLD_CONDITION_CODE("$(V) >= 1.0");
    SET_RESET_CODE("$(V) = 0.0;");
    
    SET_PARAM_NAMES({"tau"});
    
    SET_VARS({{"V", "scalar", VarAccess::READ_WRITE}});
};
IMPLEMENT_MODEL(LeakyIntegrator);

leaky_integrator_model = genn_model.create_custom_neuron_class(
    "leaky_integrator",
    
    sim_code="$(V)+= (-$(V)+$(Isyn))*(DT/$(tau));",
    threshold_condition_code="$(V) >= 1.0",
    reset_code="$(V) = 0.0;",
    
    param_names=["tau"],
    var_name_types=[("V", "scalar", VarAccess_READ_WRITE)])

Derived Parameters

"Derived parameters" are a mechanism for enhanced efficiency when running neuron models. If parameters with model-side meaning, such as time constants or conductances always appear in a certain combination in the model, then it is more efficient to pre-compute this combination and define it as a dependent parameter.

For example, because the equation defining the previous leaky integrator example has an algebraic solution, it can be more accurately solved as follows - using a derived parameter to calculate :

class LeakyIntegrator2 : public NeuronModels::Base
{
public:
    DECLARE_MODEL(LeakyIntegrator2, 1, 1);

    SET_SIM_CODE("$(V) = $(Isyn) - $(ExpTC)*($(Isyn) - $(V));");
    SET_THRESHOLD_CONDITION_CODE("$(V) >= 1.0");
    SET_RESET_CODE("$(V) = 0.0;");

    SET_PARAM_NAMES({"tau"});
    SET_VARS({{"V", "scalar", VarAccess::READ_WRITE}});
    SET_DERIVED_PARAMS({
        {"ExpTC", [](const vector<double> &pars, double dt){ return std::exp(-dt / pars[0]); }}});
};
IMPLEMENT_MODEL(LeakyIntegrator2);

leaky_integrator_2_model = genn_model.create_custom_neuron_class(
    "leaky_integrator_2",

    sim_code="$(V) = $(Isyn) - $(ExpTC)*($(Isyn) - $(V));",
    threshold_condition_code="$(V) >= 1.0",
    reset_code="$(V) = 0.0;",

    param_names=["tau"],
    var_name_types=[("V", "scalar", VarAccess_READ_WRITE)],
    derived_params=[("ExpTC", genn_model.create_dpf_class(lambda pars, dt: np.exp(-dt / pars[0]))())])

GeNN provides several additional features that might be useful when defining more complex neuron models.

Support code

Support code enables a code block to be defined that contains supporting code that will be utilized in multiple pieces of user code. Typically, these are functions that are needed in the sim code or threshold condition code. If possible, these functions should be prefixed with SUPPORT_CODE_FUNC so that both GPU and CPU versions of GeNN code have an appropriate support code function available. The support code is protected with a namespace so that it is exclusively available for the neuron population whose neurons define it. Support code is added to a model using the SET_SUPPORT_CODE() macro support_code keyword argument , for example:

SET_SUPPORT_CODE("SUPPORT_CODE_FUNC scalar mysin(float x){ return sin(x); }");

support_code="SUPPORT_CODE_FUNC scalar mysin(float x){ return sin(x); }"

Extra global parameters

Extra global parameters are parameters common to all neurons in the population. However, unlike the standard neuron parameters, they can be varied at runtime meaning they could, for example, be used to provide a global reward signal. These parameters are defined by using the SET_EXTRA_GLOBAL_PARAMS() macro extra_global_params keyword argument to specify a list of variable names and type strings (like the SET_VARS() macro var_name_types keyword argument ). For example:

SET_EXTRA_GLOBAL_PARAMS({{"R", "float"}});

extra_global_params=[("R", "float")]

These variables are available to all neurons in the population. They can also be used in synaptic code snippets; in this case it need to be addressed with a _pre or _post postfix. For example, if the model with the "R" parameter was used for the pre-synaptic neuron population, the weight update model of a synapse population could have simulation code like:

SET_SIM_CODE("$(x)= $(x)+$(R_pre);");

sim_code="$(x)= $(x)+$(R_pre);"

where we have assumed that the weight update model has a variable x and our synapse type will only be used in conjunction with pre-synaptic neuron populations that do have the extra global parameter R. If the pre-synaptic population does not have the required variable/parameter, GeNN will fail when compiling the kernels.

Additional input variables

Normally, neuron models receive the linear sum of the inputs coming from all of their synaptic inputs through the $(inSyn) variable. However neuron models can define additional input variables - allowing input from different synaptic inputs to be combined non-linearly. For example, if we wanted our leaky integrator to operate on the the product of two input currents, it could be defined as follows:

SET_ADDITIONAL_INPUT_VARS({{"Isyn2", "scalar", 1.0}});
SET_SIM_CODE("const scalar input = $(Isyn) * $(Isyn2);\n"
             "$(V) = input - $(ExpTC)*(input - $(V));");

additional_input_vars=[("Isyn2", "scalar", 1.0)],
sim_code=
    """
    const scalar input = $(Isyn) * $(Isyn2);
    $(V) = input - $(ExpTC)*(input - $(V));
    """,

where the SET_ADDITIONAL_INPUT_VARS() macroadditional_input_vars keyword argument defines the name, type and its initial value before postsynaptic inputs are applyed (see section Postsynaptic integration methods for more details).

Random number generation

Many neuron models have probabilistic terms, for example a source of noise or a probabilistic spiking mechanism. In GeNN this can be implemented by using the following functions in blocks of model code:

• $(gennrand_uniform) returns a number drawn uniformly from the interval
• $(gennrand_normal) returns a number drawn from a normal distribution with a mean of 0 and a standard deviation of 1.
• $(gennrand_exponential) returns a number drawn from an exponential distribution with .
• $(gennrand_log_normal, MEAN, STDDEV) returns a number drawn from a log-normal distribution with the specified mean and standard deviation.
• $(gennrand_gamma, ALPHA) returns a number drawn from a gamma distribution with the specified shape.
• $(gennrand_binomial, N, P) returns a number drawn from a binomial distribution with the specified shape.

Creating neuron populations with your own neuron type

Once defined in this way, new neuron models classes, can be used in network descriptions by referring to their type e.g.

networkModel.addNeuronPopulation<LeakyIntegrator>("Neurons", 1, 
                                                  LeakyIntegrator::ParamValues(20.0), // tau
                                                  LeakyIntegrator::VarValues(0.0)); // V

network_model.add_neuron_population("Neurons", 1, leaky_integrator_model, {"tau": 20.0}, {"V": 0.0})

---

Previous | Top | Next