kinase

README

Kinase Learning Implementation

This implements the Kinase learning rule, with multiple different variants being explored.

See https://github.com/emer/axon/tree/master/examples/kinaseq for exploration of the implemented equations, and https://github.com/ccnlab/kinase/tree/main/sims/kinase for biophysical basis of the equations.

Documentation

Index

• Variables
• type CaDtParams
  • func (kp *CaDtParams) Defaults()
  • func (kp *CaDtParams) Update()
• type CaParams
  • func (kp *CaParams) CurCa(ctime, utime int32, caM, caP, caD float32) (cCaM, cCaP, cCaD float32)
  • func (kp *CaParams) Defaults()
  • func (kp *CaParams) FmCa(ca float32, caM, caP, caD *float32)
  • func (kp *CaParams) FmSpike(spike float32, caM, caP, caD *float32)
  • func (kp *CaParams) IntFmTime(ctime, utime int32) int
  • func (kp *CaParams) Update()
• type Rules
  • func (i *Rules) FromString(s string) error
  • func (ev Rules) MarshalJSON() ([]byte, error)
  • func (i Rules) String() string
  • func (ev *Rules) UnmarshalJSON(b []byte) error

Variables

var KiT_Rules = kit.Enums.AddEnum(RulesN, kit.NotBitFlag, nil)

Types

type CaDtParams

type CaDtParams struct {
	MTau float32 `` /* 210-byte string literal not displayed */
	PTau float32 `` /* 314-byte string literal not displayed */
	DTau float32 `` /* 299-byte string literal not displayed */
	MDt  float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"rate = 1 / tau"`
	PDt  float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"rate = 1 / tau"`
	DDt  float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"rate = 1 / tau"`
}

CaDtParams has rate constants for integrating Ca calcium at different time scales, including final CaP = CaMKII and CaD = DAPK1 timescales for LTP potentiation vs. LTD depression factors.

func (*CaDtParams) Defaults

func (kp *CaDtParams) Defaults()

func (*CaDtParams) Update

func (kp *CaDtParams) Update()

type CaParams

type CaParams struct {
	SpikeG  float32    `` /* 189-byte string literal not displayed */
	UpdtThr float32    `` /* 308-byte string literal not displayed */
	MaxISI  int        `def:"100" desc:"maximum ISI for integrating in Opt mode -- above that just set to 0"`
	Dt      CaDtParams `view:"inline" desc:"time constants for integrating at M, P, and D cascading levels"`
}

CaParams has rate constants for integrating spike-driven Ca calcium at different time scales, including final CaP = CaMKII and CaD = DAPK1 timescales for LTP potentiation vs. LTD depression factors.

func (*CaParams) CurCa

func (kp *CaParams) CurCa(ctime, utime int32, caM, caP, caD float32) (cCaM, cCaP, cCaD float32)

CurCa returns the current Ca* values, dealing with updating for optimized spike-time update versions. ctime is current time in msec, and utime is last update time (-1 if never)

func (*CaParams) Defaults

func (kp *CaParams) Defaults()

func (*CaParams) FmCa

func (kp *CaParams) FmCa(ca float32, caM, caP, caD *float32)

FmCa computes updates to CaM, CaP, CaD from current calcium level. The SpikeG factor is NOT applied to Ca and should be pre-applied as appropriate.

func (*CaParams) FmSpike

func (kp *CaParams) FmSpike(spike float32, caM, caP, caD *float32)

FmSpike computes updates to CaM, CaP, CaD from current spike value. The SpikeG factor determines strength of increase to CaM.

func (*CaParams) IntFmTime

func (kp *CaParams) IntFmTime(ctime, utime int32) int

IntFmTime returns the interval from current time and last update time, which is -1 if never updated (in which case return is -1)

func (*CaParams) Update

func (kp *CaParams) Update()

type Rules

type Rules int32

Rules are different options for Kinase-based learning rules These are now implemented using separate Prjn types in kinasex

const (
	// SynSpkCont implements synaptic-level Ca signals at an abstract level,
	// purely driven by spikes, not NMDA channel Ca, as a product of
	// sender and recv CaSyn values that capture the decaying Ca trace
	// from spiking, qualitatively as in the NMDA dynamics.  These spike-driven
	// Ca signals are integrated in a cascaded manner via CaM,
	// then CaP (reflecting CaMKII) and finally CaD (reflecting DAPK1).
	// It uses continuous learning based on temporary DWt (TDWt) values
	// based on the TWindow around spikes, which convert into DWt after
	// a pause in synaptic activity (no arbitrary ThetaCycle boundaries).
	// There is an option to compare with SynSpkTheta by only doing DWt updates
	// at the theta cycle level, in which case the key difference is the use of
	// TDWt, which can remove some variability associated with the arbitrary
	// timing of the end of trials.
	SynSpkCont Rules = iota

	// SynNMDACont is the same as SynSpkCont with NMDA-driven calcium signals
	// computed according to the very close approximation to the
	// Urakubo et al (2008) allosteric NMDA dynamics, then integrated at P vs. D
	// time scales.  This is the most biologically realistic yet computationally
	// tractable verseion of the Kinase learning algorithm.
	SynNMDACont

	// SynSpkTheta abstracts the SynSpkCont algorithm by only computing the
	// DWt change at the end of the ThetaCycle, instead of continuous updating.
	// This allows an optimized implementation that is roughly 1/3 slower than
	// the fastest NeurSpkTheta version, while still capturing much of the
	// learning dynamics by virtue of synaptic-level integration.
	SynSpkTheta

	// NeurSpkTheta uses neuron-level spike-driven calcium signals
	// integrated at P vs. D time scales -- this is the original
	// Leabra and Axon XCAL / CHL learning rule.
	// It exhibits strong sensitivity to final spikes and thus
	// high levels of variance.
	NeurSpkTheta

	RulesN
)

The different versions of Kinase learning rules

func (*Rules) FromString

func (i *Rules) FromString(s string) error

func (Rules) MarshalJSON

func (ev Rules) MarshalJSON() ([]byte, error)

func (Rules) String

func (i Rules) String() string

func (*Rules) UnmarshalJSON

func (ev *Rules) UnmarshalJSON(b []byte) error