eprop_learning_signal_connection.h

Go to the documentation of this file.

/*
 *  eprop_learning_signal_connection.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef EPROP_LEARNING_SIGNAL_CONNECTION_H
#define EPROP_LEARNING_SIGNAL_CONNECTION_H
 
// nestkernel
#include "connection.h"
 
namespace nest
{
 
/* BeginUserDocs: synapse, abstract, learning, Bellec, e-prop plasticity, 3-factor
 
Short description
+++++++++++++++++
 
Synapse model transmitting feedback learning signals for e-prop plasticity
 
Description
+++++++++++
 
``eprop_learning_signal_connection`` is an implementation of a feedback connector from
``eprop_readout`` readout neurons to ``eprop_iaf`` or ``eprop_iaf_adapt``
recurrent neurons that transmits the learning signals :math:`L_j^t` for eligibility propagation (e-prop) plasticity and
has a static weight :math:`B_{jk}`.
 
E-prop plasticity was originally introduced and implemented in TensorFlow in :footcite:p:`Bellec2020`.
 
For more information on e-prop plasticity, see the documentation on the other e-prop models:
 
 * :doc:`eprop_iaf<../models/eprop_iaf/>`
 * :doc:`eprop_iaf_adapt<../models/eprop_iaf_adapt/>`
 * :doc:`eprop_readout<../models/eprop_readout/>`
 * :doc:`eprop_synapse<../models/eprop_synapse/>`
 
Details on the event-based NEST implementation of e-prop can be found in :footcite:p:`KorcsakGorzo2025`.
 
Parameters
++++++++++
 
The following parameters can be set in the status dictionary.
 
========== ===== ================ ======= ===============
**Individual synapse parameters**
---------------------------------------------------------
Parameter  Unit  Math equivalent  Default Description
========== ===== ================ ======= ===============
``delay``  ms    :math:`d_{jk}`       1.0 Dendritic delay
``weight`` pA    :math:`B_{jk}`       1.0 Synaptic weight
========== ===== ================ ======= ===============
 
Recordables
+++++++++++
 
The following variables can be recorded. Note that since this connection lacks
a plasticity mechanism the weight does not evolve over time.
 
============== ==== =============== ============= ===============
**Synapse recordables**
-----------------------------------------------------------------
State variable Unit Math equivalent Initial value Description
============== ==== =============== ============= ===============
``weight``     pA   :math:`B_{jk}`            1.0 Synaptic weight
============== ==== =============== ============= ===============
 
Usage
+++++
 
This model can only be used in combination with the other e-prop models
and the network architecture requires specific wiring, input, and output.
The usage is demonstrated in several
:doc:`supervised regression and classification tasks <../auto_examples/eprop_plasticity/index>`
reproducing among others the original proof-of-concept tasks in :footcite:p:`Bellec2020`.
 
Transmits
+++++++++
 
LearningSignalConnectionEvent
 
References
++++++++++
 
.. footbibliography::
 
See also
++++++++
 
Examples using this model
+++++++++++++++++++++++++
 
.. listexamples:: eprop_learning_signal_connection
 
EndUserDocs */
 
void register_eprop_learning_signal_connection( const std::string& name );
 
template < typename targetidentifierT >
class eprop_learning_signal_connection : public Connection< targetidentifierT >
{
 
public:
  typedef CommonSynapseProperties CommonPropertiesType;
 
  typedef Connection< targetidentifierT > ConnectionBase;
 
  static constexpr ConnectionModelProperties properties = ConnectionModelProperties::HAS_DELAY;
 
  eprop_learning_signal_connection()
    : ConnectionBase()
    , weight_( 1.0 )
  {
  }
 
  std::unique_ptr< SecondaryEvent > get_secondary_event();
 
  using ConnectionBase::get_delay_steps;
  using ConnectionBase::get_rport;
  using ConnectionBase::get_target;
 
  void
  check_connection( Node& s, Node& t, size_t receptor_type, const CommonPropertiesType& )
  {
    LearningSignalConnectionEvent ge;
 
    s.sends_secondary_event( ge );
    ge.set_sender( s );
    Connection< targetidentifierT >::target_.set_rport( t.handles_test_event( ge, receptor_type ) );
    Connection< targetidentifierT >::target_.set_target( &t );
  }
 
  bool
  send( Event& e, size_t t, const CommonSynapseProperties& )
  {
    e.set_weight( weight_ );
    e.set_delay_steps( get_delay_steps() );
    e.set_receiver( *get_target( t ) );
    e.set_rport( get_rport() );
    e();
    return true;
  }
 
  void get_status( Dictionary& d ) const;
 
  void set_status( const Dictionary& d, ConnectorModel& cm );
 
  void
  set_weight( const double w )
  {
    weight_ = w;
  }
 
private:
  double weight_;
};
 
template < typename targetidentifierT >
constexpr ConnectionModelProperties eprop_learning_signal_connection< targetidentifierT >::properties;
 
template < typename targetidentifierT >
void
eprop_learning_signal_connection< targetidentifierT >::get_status( Dictionary& d ) const
{
  ConnectionBase::get_status( d );
  d[ names::weight ] = weight_;
  d[ names::size_of ] = static_cast< long >( sizeof( *this ) );
}
 
template < typename targetidentifierT >
void
eprop_learning_signal_connection< targetidentifierT >::set_status( const Dictionary& d, ConnectorModel& cm )
{
  ConnectionBase::set_status( d, cm );
  d.update_value( names::weight, weight_ );
}
 
template < typename targetidentifierT >
std::unique_ptr< SecondaryEvent >
eprop_learning_signal_connection< targetidentifierT >::get_secondary_event()
{
  return std::make_unique< LearningSignalConnectionEvent >();
}
 
}  // namespace nest
 
#endif  // EPROP_LEARNING_SIGNAL_CONNECTION_H