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   `desc:"which form of synaptic calcium and subsequent learning rule to use"`
	SpikeG   float32 `` /* 363-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 */
	SUpdtThr float32 `` /* 265-byte string literal not displayed */
	RUpdtThr float32 `` /* 188-byte string literal not displayed */
	MaxISI   int     `def:"100" desc:"maximum ISI for integrating in Opt mode -- above that just set to 0"`

	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 */
	TrlDecay float32 `` /* 247-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 (
	// NeurSpkCa 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.
	NeurSpkCa Rules = iota

	// SynSpkCa integrates synapse-level spike-driven calcium signals
	// starting with a product of pre and post CaM values at the point
	// of either spike (using neuron level SpkCa params),
	// which is then integrated at P vs. D time scales.
	// Basically a synapse version of original learning rule.
	SynSpkCa

	// SynNMDACa uses synapse-level 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 an abstract version of a biologically realistic model,
	// very close in many details to a fully biophysically-grounded one.
	SynNMDACa

	RulesN
)

The time scales

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