kinase

Documentation

Index

• type CaDtParams
  • func (kp *CaDtParams) Defaults()
  • func (kp *CaDtParams) Update()
• type CaParams
  • func (kp *CaParams) CurCa(ctime, utime int32, caM, caP, caD *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) int32
  • func (kp *CaParams) Update()

Types

type CaDtParams

type CaDtParams struct {

	// CaM (calmodulin) 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.
	MTau float32 `def:"2,5" min:"1"`

	// 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.
	PTau float32 `def:"40" min:"1"`

	// 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).
	DTau float32 `def:"40" min:"1"`

	// rate = 1 / tau
	MDt float32 `view:"-" json:"-" xml:"-" edit:"-"`

	// rate = 1 / tau
	PDt float32 `view:"-" json:"-" xml:"-" edit:"-"`

	// rate = 1 / tau
	DDt float32 `view:"-" json:"-" xml:"-" edit:"-"`
	// 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) Defaults

func (kp *CaDtParams) Defaults()

func (*CaDtParams) Update

func (kp *CaDtParams) Update()

type CaParams

type CaParams struct {

	// spiking gain factor for SynSpk learning rule variants.  This alters the overall range of values, keeping them in roughly the unit scale, and affects effective learning rate.
	SpikeG float32 `def:"12"`

	// IMPORTANT: only used for SynSpkTheta learning mode: threshold on Act value for updating synapse-level Ca values -- this is purely a performance optimization that excludes random infrequent spikes -- 0.05 works well on larger networks but not smaller, which require the .01 default.
	UpdtThr float32 `def:"0.01,0.02,0.5"`

	// maximum ISI for integrating in Opt mode -- above that just set to 0
	MaxISI int32 `def:"100"`

	// time constants for integrating at M, P, and D cascading levels
	Dt CaDtParams `view:"inline"`
	// 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 int32, caM, caP, caD *float32)

CurCa updates 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) int32

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