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 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) SynNMDACa(snmdao, rca float32) float32
  • func (kp *CaParams) Update()
• type DWtParams
  • func (dp *DWtParams) DWt(caM, caP, caD float32, tdwt *float32) bool
  • func (dp *DWtParams) Defaults()
  • func (dp *DWtParams) 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 CaParams

type CaParams struct {
	Rule    Rules   `` /* 145-byte string literal not displayed */
	SpikeG  float32 `` /* 209-byte string literal not displayed */
	NMDAG   float32 `` /* 230-byte string literal not displayed */
	MTau    float32 `` /* 203-byte string literal not displayed */
	PTau    float32 `` /* 314-byte string literal not displayed */
	DTau    float32 `` /* 299-byte string literal not displayed */
	UpdtThr float32 `` /* 277-byte string literal not displayed */
	MaxISI  int     `def:"100" desc:"maximum ISI for integrating in Opt mode -- above that just set to 0"`
	Decay   bool    `` /* 127-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"`
}

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) SynNMDACa

func (kp *CaParams) SynNMDACa(snmdao, rca float32) float32

SynNMDACa returns the synaptic Ca value for SynNMDACa rule applying thresholding to rca value, and multiplying by SpikeG

func (*CaParams) Update

func (kp *CaParams) Update()

type DWtParams

type DWtParams struct {
	TWindow int     `` /* 246-byte string literal not displayed */
	DMaxPct float32 `` /* 272-byte string literal not displayed */
	DScale  float32 `` /* 186-byte string literal not displayed */
}

DWtParams has parameters controlling Kinase-based learning rules

func (*DWtParams) DWt

func (dp *DWtParams) DWt(caM, caP, caD float32, tdwt *float32) bool

TDWt computes the temporary weight change from CaP, CaD values, as the simple substraction, while applying DScale to CaD, only when CaM level is above the threshold. returns true if updated

func (*DWtParams) Defaults

func (dp *DWtParams) Defaults()

func (*DWtParams) Update

func (dp *DWtParams) Update()

type Rules

type Rules int32

Rules are different options for Kinase-based learning rules

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