Time-driven pre and postsynaptic traces

[neworderofjamie]

#152 added support for pre and postsynaptic weight update model variables to allow better encapsulation of learning vs neuron dynamics. However, these were purely event-driven dynamics which, retrospectively:

1. Even with "classic" event-driven STDP, is an inefficient approach for GPUs as loads of threads are going to waiting while a small subset are calculating exponentials - having all threads performing a much cheaper multiply every timestep is much more GPU-friendly (clearly, back in the heady days of 2018, optimising for SpiNNaker was too recent a memory)
2. Delays are annoying as you need to copy the event-driven traces between delay buffers every timestep anyway
3. Event-based traces are extra inefficient with continuous learning as you would need to calculate exponentials every timestep
4. Purely event-driven dynamics don't let you use traces to capture e.g. low-pass filtered neuron voltage

In this P.R. we introduce new syntax for time-driven pre and postsynaptic traces:

Python

For example, the following simple additive STDP rule:

stdp_additive = genn_model.create_custom_weight_update_class(
    "STDPAdditive",
    param_names=["tauPlus", "tauMinus", "aPlus", "aMinus", "wMin", "wMax"],
    var_name_types=[("g", "scalar")],
    pre_var_name_types=[("preTrace", "scalar")],
    post_var_name_types=[("postTrace", "scalar")],
    derived_params=[("aPlusScaled", genn_model.create_dpf_class(lambda pars, dt: pars[2] * (pars[5] - pars[4]))()),
                    ("aMinusScaled", genn_model.create_dpf_class(lambda pars, dt: pars[3] * (pars[5] - pars[4]))())],

    sim_code="""
        $(addToInSyn, $(g));
        const scalar dt = $(t) - $(sT_post);
        if(dt > 0) {
            const scalar timing = exp(-dt / $(tauMinus));
            const scalar newWeight = $(g) - ($(aMinusScaled) * $(postTrace) * timing);
            $(g) = fmin($(wMax), fmax($(wMin), newWeight));
        }
        """,

    learn_post_code="""        
        const scalar dt = $(t) - $(sT_pre);
        if(dt > 0) {
            const scalar timing = exp(-dt / $(tauPlus));
            const scalar newWeight = $(g) + ($(aPlusScaled) * $(preTrace) * timing);
            $(g) = fmin($(wMax), fmax($(wMin), newWeight));
        }
        """,

    pre_spike_code="""
        const scalar dt = $(t) - $(sT_pre);
        $(preTrace) = $(preTrace) * exp(-dt / $(tauPlus)) + 1.0;
        """,

    post_spike_code="""
        const scalar dt = $(t) - $(sT_post);
        $(postTrace) = $(postTrace) * exp(-dt / $(tauMinus)) + 1.0;
        """,

    is_pre_spike_time_required=True,
    is_post_spike_time_required=True)

can now be implemented more efficiently as:

stdp_additive = genn_model.create_custom_weight_update_class(
    "STDPAdditive",
    param_names=["tauPlus", "tauMinus", "aPlus", "aMinus", "wMin", "wMax"],
    var_name_types=[("g", "scalar")],
    pre_var_name_types=[("preTrace", "scalar")],
    post_var_name_types=[("postTrace", "scalar")],
    derived_params=[("aPlusScaled", genn_model.create_dpf_class(lambda pars, dt: pars[2] * (pars[5] - pars[4]))()),
                    ("aMinusScaled", genn_model.create_dpf_class(lambda pars, dt: pars[3] * (pars[5] - pars[4]))()),
                    ("tauPlusDecay", genn_model.create_dpf_class(lambda pars, dt: np.exp(-dt / pars[0]))()),
                    ("tauMinusDecay", genn_model.create_dpf_class(lambda pars, dt: np.exp(-dt / pars[1]))())],

    sim_code="""
        $(addToInSyn, $(g));
        const scalar dt = $(t) - $(sT_post);
        if(dt > 0) {
            const scalar newWeight = $(g) - ($(aMinusScaled) * $(postTrace));
            $(g) = fmin($(wMax), fmax($(wMin), newWeight));
        }
        """,

    learn_post_code="""
        const scalar dt = $(t) - $(sT_pre);
        if(dt > 0) {
            const scalar newWeight = $(g) + ($(aPlusScaled) * $(preTrace));
            $(g) = fmin($(wMax), fmax($(wMin), newWeight));
        }
        """,

    pre_spike_code="""
        $(preTrace) += 1.0;
        """,
    pre_dynamics_code="""
        $(preTrace) *= $(tauPlusDecay);
        """,
        
    post_spike_code="""
        $(postTrace) += 1.0;
        """,
    post_dynamics_code="""
        $(postTrace) *= $(tauMinusDecay);
        """,
    
    is_pre_spike_time_required=True,
    is_post_spike_time_required=True)

C++

In C++, the following macros have the same effect:

SET_PRE_DYNAMICS_CODE("$(preTrace) *= $(tauPlusDecay);\n");
SET_POST_DYNAMICS_CODE("$(postTrace) *= $(tauMinusDecay);\n");

Syntactically, this works nicely but, the resultant generated code is a bit of a mess with lots of duplication of pre and postsynaptic traces and code in a neuron update kernel. A similar approach to #201 is required for traces, but I think that's one to fix in a future PR.

[codecov]

Codecov Report

Merging #377 (99eac56) into master (5cbaa61) will increase coverage by 0.18%.
The diff coverage is 88.60%.

@@            Coverage Diff             @@
##           master     #377      +/-   ##
==========================================
+ Coverage   86.46%   86.65%   +0.18%     
==========================================
  Files          70       70              
  Lines       12331    12407      +76     
==========================================
+ Hits        10662    10751      +89     
+ Misses       1669     1656      -13     

Impacted Files	Coverage Δ
include/genn/genn/code_generator/groupMerged.h	91.21% <ø> (ø)
src/genn/genn/code_generator/groupMerged.cc	85.44% <72.50%> (+0.48%)	⬆️
src/genn/genn/neuronGroup.cc	92.71% <93.54%> (-0.22%)	⬇️
...c/genn/genn/code_generator/generateNeuronUpdate.cc	96.11% <97.00%> (+0.84%)	⬆️
include/genn/genn/code_generator/codeGenUtils.h	97.56% <100.00%> (+0.19%)	⬆️
include/genn/genn/neuronGroup.h	74.00% <100.00%> (ø)
include/genn/genn/weightUpdateModels.h	88.88% <100.00%> (+1.38%)	⬆️
src/genn/genn/code_generator/generateInit.cc	98.15% <100.00%> (+1.31%)	⬆️
src/genn/genn/code_generator/generateRunner.cc	96.58% <100.00%> (-0.01%)	⬇️
.../genn/genn/code_generator/generateSynapseUpdate.cc	97.89% <100.00%> (+0.84%)	⬆️
... and 5 more

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 5cbaa61...99eac56. Read the comment docs.

[tnowotny]

Sorry for being late with this observation but how is the code set by SET_PRE_SPIKE_CODE treated any differently from that set with SET_SIM_CODE.
Similarly, how is the code from SET_POST_SPIKE_CODE different from the code set in SET_POST_LEARN ?

For the new time-driven code snippets, I don't quite see how either of them (PRE or POST) are to be treated differently from the code set generally through SET_SYNAPSE_DYNAMICS_CODE. What am I missing? Or do you feel it benefits the user to have these options to further mark up the roles of each code snippet?

[neworderofjamie]

The main difference is that SET_XX_SPIKE_CODE and SET_XX_DYNAMICS_CODE are run per-neuron (infact in the neuron kernel)

[tnowotny]

oh - I see ... so access to variables should be constrained to pre or post-synaptic variables for pre or post-synaptic code ...?

[neworderofjamie]

exactly - you can access parameters, pre/postsynaptic weight update model variables and pre/postsynaptic neuron variables as appropriate

[tnowotny]

Yeah ... makes sense now. One typo in a comment.