Implementation of double exponential filtering for synaptic traces

[yilun-wu]

Dear authors,
In the implementation for $\alpha * \big(\epsilon * S_j(t)f^{\prime}U_i(t)\big)$ (eq. 18):

latent-predictive-learning/spiking_simulations/LPLConnection.cpp

Lines 303 to 316 in dd486d0

	const AurynWeight syn_trace_input = plasticity_sign*psp*sigma_prime;
	add_to_syntrace( didx, syn_trace_input );
	}
	}
	partial_delay->advance(); // now 'get' points to the delayed version
	pre_psp_delay->advance(); // now 'get' points to the delayed version
	// # SECOND compute outer convolution of synaptic traces
	const AurynFloat mul_follow = auryn_timestep/tau_el_decay;
	el_val_flt->follow(el_val, mul_follow);
	const AurynFloat scale_const = std::exp(-auryn_timestep/tau_el_rise);
	el_val->scale(scale_const);

It seems the two exponential filterings of $\alpha$ are done differently:

• The outer filtering which produces el_val_flt using time constant tau_el_decay through AurynVectorFloat::follow:
  https://github.com/fzenke/auryn/blob/6174a67a56074e8b72a94a763277131f62778713/src/auryn/AurynVector.h#L372-L377
• The inner filtering which produces el_val is updated through add_to_syntrace( didx, syn_trace_input ) and el_val->scale(scale_const).

My questions are:

• Why the two synaptic traces are computed differently? Why not use AurynVectorFloat::follow for both of them?
• Related to the first question, add_to_syntrace only updates the trace by adding the $\epsilon * S_j(t)f^{\prime}U_i(t)$ before scaling it. This results in the following discrete update I think:
  $\bar{c}[t+1]=\exp(-dt/\tau)(\bar{c}[t]+c[t])\approx (1-dt/\tau)(\bar{c}[t]+c[t])=(1-dt/\tau)\bar{c}[t]+(1-dt/\tau)c[t]$
  According to eq. 21, the discrete update should be:
  $\bar{c}[t+1]=(1-dt/\tau)\bar{c}[t]+(dt/\tau)c[t]$, which is implemented correctly in AurynVectorFloat::follow, which renders the inner and outer update scheme different. I am wondering if I am missing something here.
• Why is the outer filtering updated first (L313) before the inner filtering (L316)? Is this intentional?

[fzenke]

Thanks again for your question. Conventionally, I do the double filtering for synaptic traces differently when the inputs are spikes so that the jump for spike arrival in the first filter is always one regardless of the time step. However, the alpha trace does not receive spikes as inputs, so this is unnecessary here. I can only assume that I did it out of habit, but frankly, I do not remember off the top of my head.
In any case, the only thing it changes is the amplitude of the filter kernel, which can be absorbed in the learning rate. Concerning your second question, why is one filtering done first? This choice was probably unintentional, and the two are approximately the same for small time steps (or long enough time constants). Strictly speaking, all updates should be done simultaneously anyway. However, in Auryn, we deliberately do in-place operations for performance reasons.
I will keep your two tickets open until I have time to look into the code again in more detail. But as I already mentioned, it will take me some time. If we confirm discrepancies between the code and our methods, we will issue an erratum.

Thanks heaps again for your careful reading of the code, and let me know if you have any further questions.

[yilun-wu]

Understood. Thank you!