eprop_learning_signal_connection_bsshslm_2020.h

Go to the documentation of this file.

/*
 *  eprop_learning_signal_connection_bsshslm_2020.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_BSSHSLM_2020_H
#define EPROP_LEARNING_SIGNAL_CONNECTION_BSSHSLM_2020_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_bsshslm_2020`` is an implementation of a feedback connector from
``eprop_readout_bsshslm_2020`` readout neurons to ``eprop_iaf_bsshslm_2020`` or ``eprop_iaf_adapt_bsshslm_2020``
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`.
 
The suffix ``_bsshslm_2020`` follows the NEST convention to indicate in the
model name the paper that introduced it by the first letter of the authors' last
names and the publication year.
 
For more information on e-prop plasticity, see the documentation on the other e-prop models:
 
 * :doc:`eprop_iaf_bsshslm_2020<../models/eprop_iaf_bsshslm_2020/>`
 * :doc:`eprop_iaf_adapt_bsshslm_2020<../models/eprop_iaf_adapt_bsshslm_2020/>`
 * :doc:`eprop_readout_bsshslm_2020<../models/eprop_readout_bsshslm_2020/>`
 * :doc:`eprop_synapse_bsshslm_2020<../models/eprop_synapse_bsshslm_2020/>`
 
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_bsshslm_2020
 
EndUserDocs */
 
void register_eprop_learning_signal_connection_bsshslm_2020( const std::string& name );
 
template < typename targetidentifierT >
class eprop_learning_signal_connection_bsshslm_2020 : public Connection< targetidentifierT >
{
 
public:
  typedef CommonSynapseProperties CommonPropertiesType;
 
  typedef Connection< targetidentifierT > ConnectionBase;
 
  static constexpr ConnectionModelProperties properties = ConnectionModelProperties::HAS_DELAY;
 
  eprop_learning_signal_connection_bsshslm_2020()
    : 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_bsshslm_2020< targetidentifierT >::properties;
 
template < typename targetidentifierT >
void
eprop_learning_signal_connection_bsshslm_2020< 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_bsshslm_2020< 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_bsshslm_2020< targetidentifierT >::get_secondary_event()
{
  return std::make_unique< LearningSignalConnectionEvent >();
}
 
}  // namespace nest
 
#endif  // EPROP_LEARNING_SIGNAL_CONNECTION_BSSHSLM_2020_H