Fixed weight correction for stdp synapses with axonal delays for edge cases

Author: JanVogelsang

models/stdp_pl_synapse_hom_ax_delay.h

@@ -188,7 +188,9 @@ class stdp_pl_synapse_hom_ax_delay : public Connection< targetidentifierT, Axona
    */
   void correct_synapse_stdp_ax_delay( const size_t tid,
     const double t_last_spike,
+    const double t_spike_critical_interval_end,
     double& weight_revert,
+    const double K_plus_revert,
     const double t_post_spike,
     const STDPPLHomAxDelayCommonProperties& cp );
 
@@ -301,8 +303,12 @@ stdp_pl_synapse_hom_ax_delay< targetidentifierT >::send( Event& e,
     &start,
     &finish );
 
+  // Framework for STDP with predominantly axonal delays:
+  // Store pre-synaptic trace for potential later correction
+  const double K_plus_revert = Kplus_;
+
   // facilitation due to postsynaptic spikes since last pre-synaptic spike
-  double minus_dt;
+  double minus_dt = 0.; // TODO JV
   while ( start != finish )
   {
     minus_dt = t_lastspike_ + axonal_delay_ms - ( start->t_ + dendritic_delay_ms );
@@ -331,13 +337,11 @@ stdp_pl_synapse_hom_ax_delay< targetidentifierT >::send( Event& e,
   const long time_while_critical =
     e.get_rel_delivery_steps( kernel().simulation_manager.get_slice_origin() ) - 2 * get_dendritic_delay_steps() + 1;
   // Only add correction entry if there could potentially be any post-synaptic spike that occurs before the
-  // pre-synaptic one arrives at the synapse. Has to be strictly greater than min_delay, because a post-synaptic spike
-  // at time slice_origin+min_delay corresponds to the last update step in the current slice (before delivery) and was
-  // thus already known at time of delivery of the pre-synaptic one.
+  // pre-synaptic one arrives at the synapse.
   if ( time_while_critical > 0 )
   {
     static_cast< ArchivingNode* >( target )->add_correction_entry_stdp_ax_delay(
-      static_cast< SpikeEvent& >( e ), t_lastspike_, weight_revert, time_while_critical );
+      static_cast< SpikeEvent& >( e ), t_lastspike_, weight_revert, K_plus_revert, time_while_critical );
   }
 
   Kplus_ = Kplus_ * std::exp( ( t_lastspike_ - t_spike ) * cp.tau_plus_inv_ ) + 1.0;
@@ -384,28 +388,27 @@ template < typename targetidentifierT >
 inline void
 stdp_pl_synapse_hom_ax_delay< targetidentifierT >::correct_synapse_stdp_ax_delay( const size_t tid,
   const double t_last_spike,
+  const double t_spike_critical_interval_end,
   double& weight_revert,
+  const double K_plus_revert,
   const double t_post_spike,
   const STDPPLHomAxDelayCommonProperties& cp )
 {
-  const double t_spike = t_lastspike_; // no new pre-synaptic spike since last send()
   const double wrong_weight = weight_; // incorrectly transmitted weight
-  weight_ = weight_revert;             // removes the last depressive step
   Node* target = get_target( tid );
 
   const double axonal_delay_ms = get_axonal_delay_ms();
   double dendritic_delay_ms = get_dendritic_delay_ms();
 
+  const double t_spike = t_spike_critical_interval_end + dendritic_delay_ms - axonal_delay_ms;
+
   // facilitation due to new post-synaptic spike
   const double minus_dt = t_last_spike + axonal_delay_ms - ( t_post_spike + dendritic_delay_ms );
 
-  double K_plus_revert;
   // Only facilitate if not facilitated already (only if first correction for this post-spike)
   if ( minus_dt < -1.0 * kernel().connection_manager.get_stdp_eps() )
   {
-    // Kplus value at t_last_spike_ needed
-    K_plus_revert = ( Kplus_ - 1.0 ) / std::exp( ( t_last_spike - t_spike ) * cp.tau_plus_inv_ );
-    weight_ = facilitate_( weight_, K_plus_revert * std::exp( minus_dt * cp.tau_plus_inv_ ), cp );
+    weight_ = facilitate_( weight_revert, K_plus_revert * std::exp( minus_dt * cp.tau_plus_inv_ ), cp );
 
     // update weight_revert in case further correction will be required later
     weight_revert = weight_;

nestkernel/archiving_node.cpp

@@ -304,6 +304,7 @@ void
 ArchivingNode::add_correction_entry_stdp_ax_delay( SpikeEvent& spike_event,
   const double t_last_pre_spike,
   const double weight_revert,
+  const double K_plus_revert,
   const double time_while_critical )
 {
   assert( correction_entries_stdp_ax_delay_.size()
@@ -313,8 +314,8 @@ ArchivingNode::add_correction_entry_stdp_ax_delay( SpikeEvent& spike_event,
   assert( static_cast< size_t >( idx ) < correction_entries_stdp_ax_delay_.size() );
 
   const SpikeData& spike_data = spike_event.get_sender_spike_data();
-  correction_entries_stdp_ax_delay_[ idx ].push_back(
-    CorrectionEntrySTDPAxDelay( spike_data.get_lcid(), spike_data.get_syn_id(), t_last_pre_spike, weight_revert ) );
+  correction_entries_stdp_ax_delay_[ idx ].push_back( CorrectionEntrySTDPAxDelay(
+    spike_data.get_lcid(), spike_data.get_syn_id(), t_last_pre_spike, weight_revert, K_plus_revert ) );
 }
 
 void
@@ -358,7 +359,9 @@ ArchivingNode::correct_synapses_stdp_ax_delay_( const Time& t_spike )
           it_corr_entry.syn_id_,
           it_corr_entry.lcid_,
           it_corr_entry.t_last_pre_spike_,
+          ( ori + Time::step( lag + 1 ) ).get_ms(),
           it_corr_entry.weight_revert_,
+          it_corr_entry.K_plus_revert_,
           t_spike.get_ms() );
       }
       // indicate that the new spike was processed by these STDP synapses

nestkernel/archiving_node.h

@@ -112,6 +112,7 @@ class ArchivingNode : public StructuralPlasticityNode
   void add_correction_entry_stdp_ax_delay( SpikeEvent& spike_event,
     const double t_last_pre_spike,
     const double weight_revert,
+    const double K_plus_revert,
     const double time_while_critical );
 
 protected:
@@ -176,22 +177,25 @@ class ArchivingNode : public StructuralPlasticityNode
     CorrectionEntrySTDPAxDelay( const size_t lcid,
       const synindex syn_id,
       const double t_last_pre_spike,
-      const double weight_revert )
+      const double weight_revert,
+      const double K_plus_revert )
       : lcid_( lcid )
       , syn_id_( syn_id )
       , t_last_pre_spike_( t_last_pre_spike )
       , weight_revert_( weight_revert )
+      , K_plus_revert_( K_plus_revert )
     {
     }
 
     unsigned int lcid_;       //!< local connection index
     synindex syn_id_;         //!< synapse-type index
     double t_last_pre_spike_; //!< time of the last pre-synaptic spike before this spike
     double weight_revert_;    //!< synaptic weight to revert to (STDP depression needs to be undone)
+    double K_plus_revert_;    //!< pre-synaptic trace before possibly incorrect facilitation
   };
 
   //! check for correct correction entry size
-  using correction_entry_size = StaticAssert< sizeof( ArchivingNode::CorrectionEntrySTDPAxDelay ) == 24 >::success;
+  using correction_entry_size = StaticAssert< sizeof( ArchivingNode::CorrectionEntrySTDPAxDelay ) == 32 >::success;
 
 protected:
   /**

nestkernel/connection.h

@@ -179,7 +179,9 @@ class Connection
    */
   void correct_synapse_stdp_ax_delay( const size_t tid,
     const double t_last_pre_spike,
+    const double t_spike_critical_interval_end,
     double& weight_revert,
+    const double K_plus_revert,
     const double t_post_spike,
     const CommonSynapseProperties& );
 
@@ -461,9 +463,11 @@ Connection< targetidentifierT, DelayTypeT >::calibrate( const TimeConverter& tc
 template < typename targetidentifierT, typename DelayTypeT >
 inline void
 Connection< targetidentifierT, DelayTypeT >::correct_synapse_stdp_ax_delay( const size_t,
+  const double,
   const double,
   double&,
   const double,
+  const double,
   const CommonSynapseProperties& )
 {
   throw IllegalConnection( "Connection does not support correction in case of STDP with predominantly axonal delays." );

nestkernel/connection_manager.h

@@ -322,16 +322,19 @@ class ConnectionManager : public ManagerInterface
    * @param syn_id Synapse type.
    * @param lcid Local index of the synapse in the array of connections of the same type for this thread.
    * @param t_last_pre_spike Time of the last pre-synaptic spike before the pre-synaptic spike which needs a correction.
+   * @param t_spike
    * @param weight_revert The synaptic weight before depression after facilitation as baseline for potential later
    * correction.
    * @param t_post_spike Time of the current post-synaptic spike.
    */
-  void correct_synapse_stdp_ax_delay( const size_t tid,
-    const synindex syn_id,
-    const size_t lcid,
-    const double t_last_pre_spike,
+  void correct_synapse_stdp_ax_delay( size_t tid,
+    synindex syn_id,
+    size_t lcid,
+    double t_last_pre_spike,
+    double t_spike_critical_interval_end,
     double& weight_revert,
-    const double t_post_spike );
+    double K_plus_revert,
+    double t_post_spike );
 
   /**
    * Send event e to all device targets of source source_node_id
@@ -937,12 +940,14 @@ ConnectionManager::correct_synapse_stdp_ax_delay( const size_t tid,
   const synindex syn_id,
   const size_t lcid,
   const double t_last_pre_spike,
+  const double t_spike_critical_interval_end,
   double& weight_revert,
+  const double K_plus_revert,
   const double t_post_spike )
 {
   ++num_corrections_;
   connections_[ tid ][ syn_id ]->correct_synapse_stdp_ax_delay(
-    tid, syn_id, lcid, t_last_pre_spike, weight_revert, t_post_spike );
+    tid, syn_id, lcid, t_last_pre_spike, t_spike_critical_interval_end, weight_revert, K_plus_revert, t_post_spike );
 }
 
 inline void

nestkernel/connector_base.h

@@ -161,6 +161,7 @@ class ConnectorBase
    * @param syn_id Synapse type.
    * @param lcid Local index of the synapse in the array of connections of the same type for this thread.
    * @param t_last_pre_spike Time of the last pre-synaptic spike before the pre-synaptic spike which needs a correction.
+   * @param t_spike The time of the pre-synaptic spike which needs a correction.
    * @param weight_revert The synaptic weight before depression after facilitation as baseline for potential later
    * correction.
    * @param t_post_spike Time of the current post-synaptic spike.
@@ -169,7 +170,9 @@ class ConnectorBase
     const synindex syn_id,
     const size_t lcid,
     const double t_last_pre_spike,
+    const double t_spike_critical_interval_end,
     double& weight_revert,
+    const double K_plus_revert,
     const double t_post_spike ) = 0;
 
   virtual void
@@ -438,7 +441,9 @@ class Connector : public ConnectorBase
     const synindex syn_id,
     const size_t lcid,
     const double t_last_pre_spike,
+    const double t_spike_critical_interval_end,
     double& weight_revert,
+    const double K_plus_revert,
     const double t_post_spike ) override;
 
   // Implemented in connector_base_impl.h

nestkernel/connector_base_impl.h

@@ -67,13 +67,16 @@ Connector< ConnectionT >::correct_synapse_stdp_ax_delay( const size_t tid,
   const synindex syn_id,
   const size_t lcid,
   const double t_last_pre_spike,
+  const double t_spike_critical_interval_end,
   double& weight_revert,
+  const double K_plus_revert,
   const double t_post_spike )
 {
   typename ConnectionT::CommonPropertiesType const& cp = static_cast< GenericConnectorModel< ConnectionT >* >(
     kernel().model_manager.get_connection_models( tid )[ syn_id ] )
                                                            ->get_common_properties();
-  C_[ lcid ].correct_synapse_stdp_ax_delay( tid, t_last_pre_spike, weight_revert, t_post_spike, cp );
+  C_[ lcid ].correct_synapse_stdp_ax_delay(
+    tid, t_last_pre_spike, t_spike_critical_interval_end, weight_revert, K_plus_revert, t_post_spike, cp );
 }
 
 } // of namespace nest

nestkernel/event.h

@@ -1011,10 +1011,9 @@ inline void
 Event::set_stamp( Time const& s )
 {
   stamp_ = s;
-  stamp_steps_ = 0; // setting stamp_steps to zero indicates
-                    // stamp_steps needs to be recalculated from
-                    // stamp_ next time it is needed (e.g., in
-                    // get_rel_delivery_steps)
+  // setting stamp_steps to zero indicates stamp_steps needs to be recalculated from stamp_ next time it is needed
+  // (e.g., in get_rel_delivery_steps)
+  stamp_steps_ = 0;
 }
 
 inline long

nestkernel/node.cpp

@@ -144,7 +144,7 @@ Node::get_local_device_id() const
 }
 
 void
-Node::add_correction_entry_stdp_ax_delay( SpikeEvent&, const double, const double, const double )
+Node::add_correction_entry_stdp_ax_delay( SpikeEvent&, const double, const double, const double, const double )
 {
   throw UnexpectedEvent( "Node does not support framework for STDP synapses with predominantly axonal delays." );
 }

nestkernel/node.h

@@ -1025,6 +1025,7 @@ class Node
   void add_correction_entry_stdp_ax_delay( SpikeEvent& spike_event,
     const double t_last_pre_spike,
     const double weight_revert,
+    const double K_plus_revert,
     const double time_while_critical );
 
   /**