fsfffb

README

FS (Fast & Slow) FFFB Inhibition

FFFB is the feedforward (FF) and feedback (FB) inhibition mechanism, originally developed for the Leabra model.

FS fast and slow adds additional time dynamics that are already somewhat accidentally present in the Axon version of FFFB, based on an emerging consensus about the differences between three major classes of inhibitory interneurons, and their functional properties, e.g., Cardin18:

• PV: fast-spiking basket cells that target the cell bodies of excitatory neurons and coexpress the calcium-binding protein parvalbumin (PV). These are the "first responders", and are also rapidly depressing -- they provide quick control of activity, responding to FF new input and FB drive, allowing the first spiking pyramidal neurons to quickly shut off other competitors.

• SST: low-threshold spiking cells that target the distal dendrites of excitatory neurons and coexpress the peptide somatostatin (SST). These require repetitive, facilitating, afferent input to be activated, and may regulate the dendritic integration of synaptic inputs over a longer timescale. The current dependence of FB inhib on the slower integrated Act variable, which only comes on after the first spike (in order to compute the ISI), may reflect the SST dynamics.

• VIP: sparse dendrite-targeting cells that synapse onto SST interneurons and the dendrites of pyramidal neurons, and coexpress vasoactive intestinal peptide (VIP). VIP interneurons are a subset of the larger 5HT3aR-expressing interneuron class. These can provide disinhibition of SST inhibition.

Documentation

Overview

Package fsfffb provides Fast and Slow feedforward (FF) and feedback (FB) inhibition (FFFB) based on incoming spikes (FF) and outgoing spikes (FB).

This produces a robust, graded k-Winners-Take-All dynamic of sparse distributed representations having approximately k out of N neurons active at any time, where k is typically 10-20 percent of N.

Index

• type Inhib
  • func (fi *Inhib) Decay(decay float32)
  • func (fi *Inhib) GiFmFSSS() float32
  • func (fi *Inhib) Init()
  • func (fi *Inhib) InitRaw()
  • func (fi *Inhib) LayerMax(li *Inhib)
  • func (fi *Inhib) PoolMax(pi *Inhib)
  • func (fi *Inhib) SaveOrig()
  • func (fi *Inhib) SpikesFmRaw(npool int)
  • func (fi *Inhib) Zero()
• type Inhibs
• type Params
  • func (fb *Params) Defaults()
  • func (fb *Params) FS(fsi, gext float32) float32
  • func (fb *Params) FSiFmFFs(fsi *float32, ffs, fbs float32)
  • func (fb *Params) Inhib(inh *Inhib, gimult float32)
  • func (fb *Params) SSFmFBs(ssf, ssi *float32, fbs float32)
  • func (fb *Params) Update()

Types

type Inhib

type Inhib struct {
	FFsRaw   float32 `desc:"all feedforward incoming spikes into neurons in this pool -- raw aggregation"`
	FBsRaw   float32 `desc:"all feedback outgoing spikes generated from neurons in this pool -- raw aggregation"`
	GeExtRaw float32 `desc:"all extra GeExt conductances added to neurons"`
	FFs      float32 `desc:"all feedforward incoming spikes into neurons in this pool, normalized by pool size"`
	FBs      float32 `desc:"all feedback outgoing spikes generated from neurons in this pool, normalized by pool size"`
	GeExts   float32 `desc:"all extra GeExt conductances added to neurons, normalized by pool size"`
	FSi      float32 `desc:"fast spiking PV+ fast integration of FFs feedforward spikes"`
	SSi      float32 `desc:"slow spiking SST+ integration of FBs feedback spikes"`
	SSf      float32 `desc:"slow spiking facilitation factor"`
	FSGi     float32 `desc:"overall fast-spiking inhibitory conductance"`
	SSGi     float32 `desc:"overall slow-spiking inhibitory conductance"`
	Gi       float32 `desc:"overall inhibitory conductance = FSGi + SSGi"`
	GiOrig   float32 `desc:"original value of the inhibition (before pool or other effects)"`
	LayGi    float32 `` /* 127-byte string literal not displayed */
}

Inhib contains state values for computed FFFB inhibition

func (*Inhib) Decay

func (fi *Inhib) Decay(decay float32)

Decay reduces inhibition values by given decay proportion

func (*Inhib) GiFmFSSS

func (fi *Inhib) GiFmFSSS() float32

GiFmFSSS returns the sum of FSGi and SSGi as overall inhibition

func (*Inhib) Init

func (fi *Inhib) Init()

func (*Inhib) InitRaw

func (fi *Inhib) InitRaw()

InitRaw clears raw spike counters -- done every cycle prior to accumulating

func (*Inhib) LayerMax

func (fi *Inhib) LayerMax(li *Inhib)

LayerMax updates given pool-level inhib values from given layer-level with resulting value being the Max of either

func (*Inhib) PoolMax

func (fi *Inhib) PoolMax(pi *Inhib)

PoolMax updates given layer-level inhib values from given pool-level with resulting value being the Max of either

func (*Inhib) SaveOrig

func (fi *Inhib) SaveOrig()

SaveOrig saves the current Gi values as original values

func (*Inhib) SpikesFmRaw

func (fi *Inhib) SpikesFmRaw(npool int)

SpikesFmRaw updates spike values from raw, dividing by given number in pool

func (*Inhib) Zero

func (fi *Inhib) Zero()

Zero resets all accumulating inhibition factors to 0

type Inhibs

type Inhibs []Inhib

Inhibs is a slice of Inhib records

type Params

type Params struct {
	On     bool    `desc:"enable this level of inhibition"`
	Gi     float32 `` /* 249-byte string literal not displayed */
	FB     float32 `viewif:"On" min:"0" def:"1" desc:"amount of FB spikes included in FF for driving FS"`
	FSTau  float32 `` /* 188-byte string literal not displayed */
	SS     float32 `` /* 152-byte string literal not displayed */
	SSfTau float32 `` /* 284-byte string literal not displayed */
	SSiTau float32 `` /* 215-byte string literal not displayed */
	FS0    float32 `` /* 145-byte string literal not displayed */

	FSDt  float32 `inactive:"+" view:"-" json:"-" xml:"-" desc:"rate = 1 / tau"`
	SSfDt float32 `inactive:"+" view:"-" json:"-" xml:"-" desc:"rate = 1 / tau"`
	SSiDt float32 `inactive:"+" view:"-" json:"-" xml:"-" desc:"rate = 1 / tau"`
}

Params parameterizes feedforward (FF) and feedback (FB) inhibition (FFFB) based on incoming spikes (FF) and outgoing spikes (FB) across Fast (PV+) and Slow (SST+) timescales. FF -> PV -> FS fast spikes, FB -> SST -> SS slow spikes (slow to get going)

func (*Params) Defaults

func (fb *Params) Defaults()

func (*Params) FS

func (fb *Params) FS(fsi, gext float32) float32

FS returns the current effective FS value based on fsi and fsd

func (*Params) FSiFmFFs

func (fb *Params) FSiFmFFs(fsi *float32, ffs, fbs float32)

FSiFmFFs updates fast-spiking inhibition from FFs spikes

func (*Params) Inhib

func (fb *Params) Inhib(inh *Inhib, gimult float32)

Inhib is full inhibition computation for given inhib state which has aggregated FFs and FBs spiking values

func (*Params) SSFmFBs

func (fb *Params) SSFmFBs(ssf, ssi *float32, fbs float32)

SSFmFBs updates slow-spiking inhibition from FBs

func (*Params) Update

func (fb *Params) Update()