kinase

README

Kinase Learning Implementation

This implements central elements of the Kinase learning rule, including variables with associated time constants used for integrating calcium signals through the cascade of progressively longer time-integrals, from Ca -> CaM calmodulin (at MTau) -> CaMKII (CaP at PTau for LTP role) -> DAPK1 (CaD at DTau for LTD role).

See kinaseq example for an exploration of the implemented equations, and kinase repository for documentation and simulations about the biophysical basis of the equations.

Time constants and Variables

• MTau (2 or 5) = calmodulin (CaM) time constant in cycles (msec) -- for synaptic-level integration this integrates on top of Ca signal from send->CaSyn * recv->CaSyn, each of which are typically integrated with a 30 msec Tau.

• PTau (40) = LTP spike-driven Ca factor (CaP) time constant in cycles (msec), simulating CaMKII in the Kinase framework, with 40 on top of MTau roughly tracking the biophysical rise time. Computationally, CaP represents the plus phase learning signal that reflects the most recent past information.

• DTau (40) = LTD spike-driven Ca factor (CaD) time constant in cycles (msec), simulating DAPK1 in Kinase framework. Computationally, CaD represents the minus phase learning signal that reflects the expectation representation prior to experiencing the outcome (in addition to the outcome).

Documentation

Index

• Variables
• type CaDtParams
  • func (kp *CaDtParams) CaAtT(ti int32, caM, caP, caD *float32)
  • func (kp *CaDtParams) Defaults()
  • func (kp *CaDtParams) Update()
• type CaParams
  • func (kp *CaParams) CurCa(ctime, utime float32, caM, caP, caD *float32)
  • func (kp *CaParams) Defaults()
  • func (kp *CaParams) FmCa(ca float32, caM, caP, caD *float32)
  • func (kp *CaParams) FmCa4(ca float32, caM, caP, caD *float32)
  • func (kp *CaParams) FmSpike(spike float32, caM, caP, caD *float32)
  • func (kp *CaParams) IntFmTime(ctime, utime float32) int32
  • 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     `` /* 233-byte string literal not displayed */
	PTau   float32     `` /* 310-byte string literal not displayed */
	DTau   float32     `` /* 362-byte string literal not displayed */
	ExpAdj slbool.Bool `` /* 158-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"`

	M4Dt float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"4 * rate = 1 / tau"`
	P4Dt float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"4 * rate = 1 / tau"`
	D4Dt float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"4 * rate = 1 / tau"`
	// contains filtered or unexported fields
}

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

func (kp *CaDtParams) CaAtT(ti int32, caM, caP, caD *float32)

CaAtT computes the 3 Ca values at (currentTime + ti), assuming 0 new Ca incoming (no spiking). It uses closed-form exponential functions.

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 */
	MaxISI int32   `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"`
	// contains filtered or unexported fields
}

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 float32, caM, caP, caD *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) to avoid running out of float32 precision, ctime should be reset periodically along with the Ca values -- in axon this happens during SlowAdapt.

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

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

FmCa4 computes updates to CaM, CaP, CaD from current calcium level using 4x rate constants, to be called at 4 msec intervals. This introduces some error but is significantly faster and does not affect overall learning.

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 float32) int32

IntFmTime returns the interval from current time and last update time, which is 0 if never updated

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