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 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
• type SynParams
  • func (kp *SynParams) CurCa(ctime, stime int32, caM, caP, caD float32) (cCaM, cCaP, cCaD float32)
  • func (kp *SynParams) DWt(caP, caD float32) float32
  • func (kp *SynParams) Defaults()
  • func (kp *SynParams) FmCa(ca float32, caM, caP, caD *float32)
  • func (kp *SynParams) FmSpike(spike float32, caM, caP, caD *float32)
  • func (kp *SynParams) ISIFmTime(ctime, stime int32) int
  • func (kp *SynParams) SynNMDACa(snmdao, rca float32) float32
  • func (kp *SynParams) Update()

Variables

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

Types

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

type SynParams

type SynParams struct {
	Rule     Rules   `desc:"which learning rule to use"`
	SpikeG   float32 `` /* 364-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 */
	DScale   float32 `` /* 208-byte string literal not displayed */
	OptInteg bool    `` /* 198-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"`
}

SynParams has rate constants for averaging over activations at different time scales, to produce the running average activation values that then drive learning.

func (*SynParams) CurCa

func (kp *SynParams) CurCa(ctime, stime 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 stime is last spike time (-1 if never)

func (*SynParams) DWt

func (kp *SynParams) DWt(caP, caD float32) float32

DWt computes the weight change from CaP, CaD values

func (*SynParams) Defaults

func (kp *SynParams) Defaults()

func (*SynParams) FmCa

func (kp *SynParams) 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 (*SynParams) FmSpike

func (kp *SynParams) 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 (*SynParams) ISIFmTime

func (kp *SynParams) ISIFmTime(ctime, stime int32) int

ISIFmTime returns the inter spike interval from current time and last spike time, which is -1 if never spiked (in which case return ISI is -1)

func (*SynParams) SynNMDACa

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

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

func (*SynParams) Update

func (kp *SynParams) Update()