axon

Oct 9, 2023

Changes in this version

type HipConfig

+ EC5Clamp bool

Sep 8, 2023

Changes in this version

type LHbParams

+ func (lh *LHbParams) DAFmPVs(pvPos, pvNeg, vsPatchPos float32) (burst, dip, da, rew float32)

type PVLV

+ func (pp *PVLV) DAFmPVs(pvPos, pvNeg, vsPatchPos float32) (burst, dip, da, rew float32)

+ func (pp *PVLV) PVnegEstFmUSs(uss []float32) (pvNegSum, pvNeg float32)

+ func (pp *PVLV) PVposEstFmUSsDrives(uss, drives []float32) (pvPosSum, pvPos float32)

type USParams

+ PVnegGain float32

+ PVnegWts []float32

+ PVposGain float32

+ PVposWts []float32

+ USnegGains []float32

Sep 7, 2023

Changes in this version

+ func AddGlbUSneg(ctx *Context, di uint32, gvar GlobalVars, negIdx uint32, val float32)

+ func AddGlbUSposV(ctx *Context, di uint32, gvar GlobalVars, posIdx uint32, val float32)

+ func GlbUSposV(ctx *Context, di uint32, gvar GlobalVars, posIdx uint32) float32

+ func GlobalSetRew(ctx *Context, di uint32, rew float32, hasRew bool)

+ func GlobalsReset(ctx *Context)

+ func LogisticFun(v, gain float32) float32

+ func PVLVNormFun(raw float32) float32

+ func SetGlbUSposV(ctx *Context, di uint32, gvar GlobalVars, posIdx uint32, val float32)

type Context

+ func (ctx *Context) GlobalUSposIdx(di uint32, gvar GlobalVars, posIdx uint32) uint32

+ type DriveParams struct

+ Base []float32

+ DriveMin float32

+ Dt []float32

+ Satisfaction []float32

+ Tau []float32

+ func (dp *DriveParams) AddTo(ctx *Context, di uint32, drv uint32, delta float32) float32

+ func (dp *DriveParams) Alloc(nDrives int)

+ func (dp *DriveParams) Defaults()

+ func (dp *DriveParams) EffectiveDrive(ctx *Context, di uint32, i uint32) float32

+ func (dp *DriveParams) ExpStep(ctx *Context, di uint32, drv uint32, dt, base float32) float32

+ func (dp *DriveParams) ExpStepAll(ctx *Context, di uint32)

+ func (dp *DriveParams) SoftAdd(ctx *Context, di uint32, drv uint32, delta float32) float32

+ func (dp *DriveParams) ToBaseline(ctx *Context, di uint32)

+ func (dp *DriveParams) ToZero(ctx *Context, di uint32)

+ func (dp *DriveParams) Update()

+ func (dp *DriveParams) VarToZero(ctx *Context, di uint32, gvar GlobalVars)

+ type GiveUpParams struct

+ Gain float32

+ MinPVposEst float32

+ NegThr float32

+ func (gp *GiveUpParams) Defaults()

+ func (gp *GiveUpParams) Prob(pvDiff float32, rnd erand.Rand) (float32, bool)

type GlobalVars

+ const GvCeMneg

+ const GvCeMpos

+ const GvCuriosityPoolGated

+ const GvEffort

+ const GvGaveUp

+ const GvGiveUp

+ const GvGiveUpDiff

+ const GvGiveUpProb

+ const GvHadNegUSOutcome

+ const GvHadPosUS

+ const GvHadRew

+ const GvLHbPVDA

+ const GvNegUSOutcome

+ const GvOFCposUSPTMaint

+ const GvPVneg

+ const GvPVnegSum

+ const GvPVpos

+ const GvPVposEst

+ const GvPVposEstDisc

+ const GvPVposEstSum

+ const GvPVposSum

+ const GvTime

+ const GvUSnegRaw

+ const GvVSMatrixPoolGated

+ const GvVSPatchPos

+ const GvVSPatchPosPrev

+ const GvVSPatchPosSum

+ const GvVSPatchPrev

+ type LHbParams struct

+ BurstGain float32

+ DipGain float32

+ NegThr float32

+ func (lh *LHbParams) DAforNoUS(ctx *Context, di uint32, vsPatchPos float32)

+ func (lh *LHbParams) DAforUS(ctx *Context, di uint32, pvPos, pvNeg, vsPatchPos float32)

+ func (lh *LHbParams) Defaults()

+ func (lh *LHbParams) Reset(ctx *Context, di uint32)

+ func (lh *LHbParams) Update()

type LayerParams

+ VTA VTAParams

type NetIdxs

+ GvUSnegStride uint32

+ GvUSposOff uint32

+ GvUSposStride uint32

+ PVLVNNegUSs uint32

+ PVLVNPosUSs uint32

type Network

+ func (net *Network) AddOFCnegUS(ctx *Context, nUSs, ofcY, ofcX int, space float32) (ofc, ofcCT, ofcPT, ofcPTp, ofcMD *Layer)

+ func (net *Network) AddOFCposUS(ctx *Context, nUSs, nY, ofcY, ofcX int, space float32) (ofc, ofcCT, ofcPT, ofcPTp, ofcMD, notMaint *Layer)

type NetworkBase

+ PVLV PVLV

type NeuronVars

+ const GeIntNorm

type PVLV

+ GiveUp GiveUpParams

+ NNegUSs uint32

+ NPosUSs uint32

+ USs USParams

+ func (pp *PVLV) AddTimeEffort(ctx *Context, di uint32, effort float32)

+ func (pp *PVLV) GiveUpFmPV(ctx *Context, di uint32, pvNeg float32, rnd erand.Rand) bool

+ func (pp *PVLV) PVDA(ctx *Context, di uint32, rnd erand.Rand)

+ func (pp *PVLV) PVneg(ctx *Context, di uint32) (pvNegSum, pvNeg float32)

+ func (pp *PVLV) PVpos(ctx *Context, di uint32) (pvPosSum, pvPos float32)

+ func (pp *PVLV) PVposEst(ctx *Context, di uint32) (pvPosSum, pvPos float32)

+ func (pp *PVLV) PVposEstFmUSs(ctx *Context, di uint32, uss []float32) (pvPosSum, pvPos float32)

+ func (pp *PVLV) PVsFmUSs(ctx *Context, di uint32)

+ func (pp *PVLV) ResetGiveUp(ctx *Context, di uint32)

+ func (pp *PVLV) ResetGoalState(ctx *Context, di uint32)

+ func (pp *PVLV) SetDrives(ctx *Context, di uint32, curiosity, magnitude float32, drives ...int)

+ func (pp *PVLV) SetNUSs(ctx *Context, nPos, nNeg int)

+ func (pp *PVLV) SetUS(ctx *Context, di uint32, valence ValenceTypes, usIdx int, magnitude float32)

+ func (pp *PVLV) Step(ctx *Context, di uint32, rnd erand.Rand)

+ func (pp *PVLV) TimeEffortReset(ctx *Context, di uint32)

+ func (pp *PVLV) USnegIdx(simUsIdx int) int

+ func (pp *PVLV) USposIdx(simUsIdx int) int

+ func (pp *PVLV) VSPatchNewState(ctx *Context, di uint32)

type TrgAvgActParams

+ GiBaseInit float32

+ type USParams struct

+ NegGains []float32

+ NegUSOutcomeThr float32

+ PVNegGain float32

+ PVNegWts []float32

+ PVPosGain float32

+ PVPosWts []float32

+ USposEst []float32

+ func (us *USParams) Alloc(nPos, nNeg int)

+ func (us *USParams) Defaults()

+ func (us *USParams) NegUSOutcome(ctx *Context, di uint32, usIdx int, mag float32) bool

+ func (us *USParams) USnegFromRaw(ctx *Context, di uint32)

+ func (us *USParams) USnegToZero(ctx *Context, di uint32)

+ func (us *USParams) USposToZero(ctx *Context, di uint32)

+ func (us *USParams) Update()

+ type UrgencyParams struct

+ Power int32

+ Thr float32

+ U50 float32

+ func (ur *UrgencyParams) AddEffort(ctx *Context, di uint32, inc float32)

+ func (ur *UrgencyParams) Defaults()

+ func (ur *UrgencyParams) Reset(ctx *Context, di uint32)

+ func (ur *UrgencyParams) Update()

+ func (ur *UrgencyParams) Urge(ctx *Context, di uint32) float32

+ func (ur *UrgencyParams) UrgeFun(urgency float32) float32

+ type VTAParams struct

+ CeMGain float32

+ LHbGain float32

+ func (vt *VTAParams) Defaults()

+ func (vt *VTAParams) Update()

+ func (vt *VTAParams) VTADA(ctx *Context, di uint32, ach float32, hasRew bool)

Aug 24, 2023

Changes in this version

type DAModTypes

+ func (i DAModTypes) Desc() string

type GPLayerTypes

+ func (i GPLayerTypes) Desc() string

type GlobalVTAType

+ func (i GlobalVTAType) Desc() string

type GlobalVars

+ func (i GlobalVars) Desc() string

type LayerTypes

+ func (i LayerTypes) Desc() string

type Network

+ func (net *Network) ConnectUSToBLA(us, blaAcq, blaExt *Layer) (toAcq, toExt *Prjn)

type NeuronAvgVars

+ func (i NeuronAvgVars) Desc() string

type NeuronFlags

+ func (i NeuronFlags) Desc() string

type NeuronIdxs

+ func (i NeuronIdxs) Desc() string

type NeuronVars

+ func (i NeuronVars) Desc() string

type PrjnGTypes

+ func (i PrjnGTypes) Desc() string

type PrjnTypes

+ func (i PrjnTypes) Desc() string

type SynapseCaVars

+ func (i SynapseCaVars) Desc() string

type SynapseIdxs

+ func (i SynapseIdxs) Desc() string

type SynapseVars

+ func (i SynapseVars) Desc() string

type ValenceTypes

+ func (i ValenceTypes) Desc() string

Jul 29, 2023

Changes in this version

type HipConfig

+ EC5ClampSrc string

+ EC5ClampTest bool

+ EC5ClampThr float32

+ MossyDelta float32

+ MossyDeltaTest float32

type LayerBase

+ func (ly *LayerBase) RecvName(receiver string) *Prjn

+ func (ly *LayerBase) RecvNameType(receiver, typ string) *Prjn

+ func (ly *LayerBase) SendName(sender string) *Prjn

+ func (ly *LayerBase) SendNameType(sender, typ string) *Prjn

Jul 27, 2023

Changes in this version

type BLAPrjnParams

+ AChThr float32

+ USTrace float32

Jul 26, 2023

Changes in this version

type HipConfig

+ MossyDel float32

+ MossyDelTest float32

+ ThetaHigh float32

+ ThetaLow float32

type Network

+ func (net *Network) ConfigLoopsHip(ctx *Context, man *looper.Manager, hip *HipConfig, pretrain *bool)

Jul 17, 2023

Changes in this version

+ type HipConfig struct

+ CA1NNrn evec.Vec2i

+ CA3Size evec.Vec2i

+ CA3ToCA1PCon float32

+ DGRatio float32

+ DGToCA3PCon float32

+ EC2LatRadius int

+ EC2LatSigma float32

+ EC2Size evec.Vec2i

+ EC2ToCA3PCon float32

+ EC2ToDGPCon float32

+ EC3NNrn evec.Vec2i

+ EC3NPool evec.Vec2i

+ EC3ToEC2PCon float32

+ func (hip *HipConfig) Defaults()

type Network

+ func (net *Network) AddHip(ctx *Context, hip *HipConfig, space float32) (ec2, ec3, dg, ca3, ca1, ec5 *Layer)

Jul 14, 2023

Changes in this version

+ type HipPrjnParams struct

+ Err float32

+ Hebb float32

+ SAvgCor float32

+ SAvgThr float32

+ SNominal float32

+ func (hp *HipPrjnParams) Defaults()

+ func (hp *HipPrjnParams) Update()

type PrjnParams

+ Hip HipPrjnParams

+ func (pj *PrjnParams) DWtSynHip(ctx *Context, syni, si, ri, di uint32, layPool, subPool *Pool, isTarget bool)

+ func (pj *PrjnParams) HipDefaults()

type PrjnTypes

+ const HipPrjn

Jul 7, 2023

Changes in this version

+ func SaveWeightsIfConfigSet(net *Network, cfgWts bool, ctrString, runName string) string

type LayerBase

+ func (ly *LayerBase) AddClass(cls string)

type NetworkBase

+ func (nt *NetworkBase) SaveAllLayerInhibs(filename gi.FileName) error

+ func (nt *NetworkBase) SaveAllParams(filename gi.FileName) error

+ func (nt *NetworkBase) SaveAllPrjnScales(filename gi.FileName) error

+ func (nt *NetworkBase) SaveNonDefaultParams(filename gi.FileName) error

+ func (nt *NetworkBase) SaveParamsSnapshot(pars *params.Sets, cfg any) error

type PrjnBase

+ func (pj *PrjnBase) AddClass(cls string)

Jun 28, 2023

Changes in this version

type GPU

+ MaxBufferBytes uint32

+ SynapseCas0 []float32

+ SynapseCas1 []float32

+ SynapseCas2 []float32

+ SynapseCas3 []float32

+ SynapseCas4 []float32

+ SynapseCas5 []float32

+ SynapseCas6 []float32

+ SynapseCas7 []float32

+ func (gp *GPU) ConfigSynCaBuffs()

+ func (gp *GPU) RunPipelineMemWait(cmd vk.CommandBuffer, name string, n int)

+ func (gp *GPU) RunPipelineNoWait(cmd vk.CommandBuffer, name string, n int)

+ func (gp *GPU) RunPipelineOffset(cmd vk.CommandBuffer, name string, n, off int)

+ func (gp *GPU) SynCaBuff(idx uint32) []float32

+ func (gp *GPU) SynDataNs() (nCmd, nPer, nLast int)

+ func (gp *GPU) TestSynCa() bool

+ func (gp *GPU) TestSynCaCmd() vk.CommandBuffer

type NetIdxs

+ GPUMaxBuffFloats uint32

+ GPUSynCaBanks uint32

+ type PushOff struct

+ Off uint32

Jun 20, 2023

Changes in this version

type ActAvgVals

+ AdaptThr float32

type GPU

+ SynCas *vgpu.VarSet

+ func (gp *GPU) CopySynCaFmStaging()

+ func (gp *GPU) CopySynCaToStaging()

+ func (gp *GPU) SyncRegionSynCas(vnm string) vgpu.MemReg

+ func (gp *GPU) SyncSynCaFmGPU()

+ func (gp *GPU) SyncSynCaToGPU()

type Layer

+ func (ly *Layer) VSPatchAdaptThr(ctx *Context)

type NetIdxs

+ NSynCaBanks uint32

type Network

+ var TheNetwork *Network

+ func GlobalNetwork(ctx *Context) *Network

type NetworkBase

+ SynapseCas0 []float32

+ SynapseCas1 []float32

+ SynapseCas2 []float32

+ SynapseCas3 []float32

+ SynapseCas4 []float32

+ SynapseCas5 []float32

+ SynapseCas6 []float32

type VSPatchParams

+ Gain float32

+ ThrInit float32

+ ThrLRate float32

+ ThrNonRew float32

+ func (vp *VSPatchParams) ThrVal(act, thr float32) float32

Jun 9, 2023

Changes in this version

+ var AvgMaxFloatFromIntErr func()

+ var AvgMaxFloatFromIntErrMu sync.Mutex

+ var KiT_GlobalVTAType = kit.Enums.AddEnum(GlobalVTATypeN, kit.NotBitFlag, nil)

+ var KiT_GlobalVars = kit.Enums.AddEnum(GlobalVarsN, kit.NotBitFlag, nil)

+ var KiT_NeuronAvgVars = kit.Enums.AddEnum(NeuronAvgVarsN, kit.NotBitFlag, nil)

+ var KiT_NeuronIdxs = kit.Enums.AddEnum(NeuronIdxsN, kit.NotBitFlag, nil)

+ var KiT_NeuronVars = kit.Enums.AddEnum(NeuronVarsN, kit.NotBitFlag, nil)

+ var KiT_SynapseCaVars = kit.Enums.AddEnum(SynapseCaVarsN, kit.NotBitFlag, nil)

+ var KiT_SynapseIdxs = kit.Enums.AddEnum(SynapseIdxsN, kit.NotBitFlag, nil)

+ var KiT_SynapseVars = kit.Enums.AddEnum(SynapseVarsN, kit.NotBitFlag, nil)

+ var Networks []*Network

+ var NeuronVarNames []string

+ var SynapseVarNames []string

+ func AddGlbDrvV(ctx *Context, di uint32, drIdx uint32, gvar GlobalVars, val float32)

+ func AddGlbV(ctx *Context, di uint32, gvar GlobalVars, val float32)

+ func AddNrnAvgV(ctx *Context, ni uint32, nvar NeuronAvgVars, val float32)

+ func AddNrnV(ctx *Context, ni, di uint32, nvar NeuronVars, val float32)

+ func AddSynCaV(ctx *Context, syni, di uint32, svar SynapseCaVars, val float32)

+ func AddSynV(ctx *Context, syni uint32, svar SynapseVars, val float32)

+ func DriveVarToZero(ctx *Context, di uint32, gvar GlobalVars)

+ func DrivesAddTo(ctx *Context, di uint32, drv uint32, delta float32) float32

+ func DrivesEffectiveDrive(ctx *Context, di uint32, i uint32) float32

+ func DrivesExpStep(ctx *Context, di uint32, drv uint32, dt, base float32) float32

+ func DrivesExpStepAll(ctx *Context, di uint32)

+ func DrivesSoftAdd(ctx *Context, di uint32, drv uint32, delta float32) float32

+ func DrivesToBaseline(ctx *Context, di uint32)

+ func DrivesToZero(ctx *Context, di uint32)

+ func EffortAddEffort(ctx *Context, di uint32, inc float32)

+ func EffortDiscFmEffort(ctx *Context, di uint32) float32

+ func EffortGiveUp(ctx *Context, di uint32) bool

+ func EffortReset(ctx *Context, di uint32)

+ func GlbDrvV(ctx *Context, di uint32, drIdx uint32, gvar GlobalVars) float32

+ func GlbUSneg(ctx *Context, di uint32, negIdx uint32) float32

+ func GlbV(ctx *Context, di uint32, gvar GlobalVars) float32

+ func GlbVTA(ctx *Context, di uint32, vtaType GlobalVTAType, gvar GlobalVars) float32

+ func LHbFmPVVS(ctx *Context, di uint32, pvPos, pvNeg, vsPatchPos float32)

+ func LHbReset(ctx *Context, di uint32)

+ func LHbShouldGiveUp(ctx *Context, di uint32) bool

+ func MulNrnAvgV(ctx *Context, ni uint32, nvar NeuronAvgVars, val float32)

+ func MulNrnV(ctx *Context, ni, di uint32, nvar NeuronVars, val float32)

+ func MulSynCaV(ctx *Context, syni, di uint32, svar SynapseCaVars, val float32)

+ func MulSynV(ctx *Context, syni uint32, svar SynapseVars, val float32)

+ func NeuroModInit(ctx *Context, di uint32)

+ func NeuroModSetRew(ctx *Context, di uint32, rew float32, hasRew bool)

+ func NrnAvgV(ctx *Context, ni uint32, nvar NeuronAvgVars) float32

+ func NrnClearFlag(ctx *Context, ni, di uint32, flag NeuronFlags)

+ func NrnHasFlag(ctx *Context, ni, di uint32, flag NeuronFlags) bool

+ func NrnI(ctx *Context, ni uint32, idx NeuronIdxs) uint32

+ func NrnIsOff(ctx *Context, ni uint32) bool

+ func NrnSetFlag(ctx *Context, ni, di uint32, flag NeuronFlags)

+ func NrnV(ctx *Context, ni, di uint32, nvar NeuronVars) float32

+ func PVLVDA(ctx *Context, di uint32) float32

+ func PVLVDAImpl(ctx *Context, di uint32, ach float32, hasRew bool) float32

+ func PVLVDriveUpdt(ctx *Context, di uint32)

+ func PVLVHasNegUS(ctx *Context, di uint32) bool

+ func PVLVHasPosUS(ctx *Context, di uint32) bool

+ func PVLVInitDrives(ctx *Context, di uint32)

+ func PVLVInitUS(ctx *Context, di uint32)

+ func PVLVNegPV(ctx *Context, di uint32) float32

+ func PVLVNetPV(ctx *Context, di uint32) float32

+ func PVLVNewState(ctx *Context, di uint32, hadRew bool)

+ func PVLVPosPV(ctx *Context, di uint32) float32

+ func PVLVPosPVFmDriveEffort(ctx *Context, usValue, drive, effort float32) float32

+ func PVLVReset(ctx *Context, di uint32)

+ func PVLVSetDrive(ctx *Context, di uint32, dr uint32, val float32)

+ func PVLVSetNegUS(ctx *Context, di uint32, usn uint32, val float32)

+ func PVLVSetPosUS(ctx *Context, di uint32, usn uint32, val float32)

+ func PVLVUSStimVal(ctx *Context, di uint32, usIdx uint32, valence ValenceTypes) float32

+ func PVLVUrgencyUpdt(ctx *Context, di uint32, effort float32)

+ func PVLVVSPatchMax(ctx *Context, di uint32) float32

+ func SetAvgMaxFloatFromIntErr(fun func())

+ func SetGlbDrvV(ctx *Context, di uint32, drIdx uint32, gvar GlobalVars, val float32)

+ func SetGlbUSneg(ctx *Context, di uint32, negIdx uint32, val float32)

+ func SetGlbV(ctx *Context, di uint32, gvar GlobalVars, val float32)

+ func SetGlbVTA(ctx *Context, di uint32, vtaType GlobalVTAType, gvar GlobalVars, val float32)

+ func SetNrnAvgV(ctx *Context, ni uint32, nvar NeuronAvgVars, val float32)

+ func SetNrnI(ctx *Context, ni uint32, idx NeuronIdxs, val uint32)

+ func SetNrnV(ctx *Context, ni, di uint32, nvar NeuronVars, val float32)

+ func SetSynCaV(ctx *Context, syni, di uint32, svar SynapseCaVars, val float32)

+ func SetSynI(ctx *Context, syni uint32, idx SynapseIdxs, val uint32)

+ func SetSynV(ctx *Context, syni uint32, svar SynapseVars, val float32)

+ func SynCaV(ctx *Context, syni, di uint32, svar SynapseCaVars) float32

+ func SynI(ctx *Context, syni uint32, idx SynapseIdxs) uint32

+ func SynV(ctx *Context, syni uint32, svar SynapseVars) float32

+ func USnegToZero(ctx *Context, di uint32)

+ func UrgeFmUrgency(ctx *Context, di uint32) float32

+ func UrgencyAddEffort(ctx *Context, di uint32, inc float32)

+ func UrgencyReset(ctx *Context, di uint32)

+ func VTADAFmRaw(ctx *Context, di uint32, ach float32, hasRew bool)

+ func VTAReset(ctx *Context, di uint32)

+ func VTAZeroVals(ctx *Context, di uint32, vtaType GlobalVTAType)

type ActParams

+ AttnMod AttnParams

+ GabaB chans.GABABParams

+ Spikes SpikeParams

+ func (ac *ActParams) AddGeNoise(ctx *Context, ni, di uint32)

+ func (ac *ActParams) AddGiNoise(ctx *Context, ni, di uint32)

+ func (ac *ActParams) SpikeFmVmVars(nrnISI, nrnISIAvg, nrnSpike, nrnSpiked, nrnAct *float32, nrnVm float32)

type AttnParams

+ RTThr float32

type CaLrnParams

+ func (np *CaLrnParams) CaLrns(ctx *Context, ni, di uint32)

+ func (np *CaLrnParams) VgccCaFmSpike(ctx *Context, ni, di uint32)

type Context

+ NetIdxs NetIdxs

+ NeuronAvgVars NeuronAvgVarStrides

+ NeuronIdxs NeuronIdxStrides

+ NeuronVars NeuronVarStrides

+ SlowCtr int32

+ SlowInterval int32

+ SynCaCtr float32

+ SynapseCaVars SynapseCaStrides

+ SynapseIdxs SynapseIdxStrides

+ SynapseVars SynapseVarStrides

+ func (ctx *Context) CopyNetStridesFrom(srcCtx *Context)

+ func (ctx *Context) GlobalDriveIdx(di uint32, drIdx uint32, gvar GlobalVars) uint32

+ func (ctx *Context) GlobalIdx(di uint32, gvar GlobalVars) uint32

+ func (ctx *Context) GlobalUSnegIdx(di uint32, negIdx uint32) uint32

+ func (ctx *Context) GlobalVNFloats() uint32

+ func (ctx *Context) GlobalVTAIdx(di uint32, vtaType GlobalVTAType, gvar GlobalVars) uint32

+ func (ctx *Context) SetGlobalStrides()

+ func (ctx *Context) SlowInc() bool

type GPU

+ Idxs *vgpu.VarSet

+ Syns *vgpu.VarSet

+ func (gp *GPU) CopyGBufToStaging()

+ func (gp *GPU) RunDWtCmd() vk.CommandBuffer

+ func (gp *GPU) RunNewStateCmd() vk.CommandBuffer

+ func (gp *GPU) SyncRegionSyns(vnm string) vgpu.MemReg

+ func (gp *GPU) SyncStateGBufToGPU()

+ type GlobalVTAType int32

+ const GlobalVTATypeN

+ const GvVtaPrev

+ const GvVtaRaw

+ const GvVtaVals

+ func (ev *GlobalVTAType) UnmarshalJSON(b []byte) error

+ func (ev GlobalVTAType) MarshalJSON() ([]byte, error)

+ func (i *GlobalVTAType) FromString(s string) error

+ func (i GlobalVTAType) String() string

+ type GlobalVars int32

+ const GlobalVarsN

+ const GvACh

+ const GvAChRaw

+ const GvBaseDrives

+ const GvDA

+ const GvDrives

+ const GvDrivesTau

+ const GvDrivesUSDec

+ const GvEffortCurMax

+ const GvEffortDisc

+ const GvEffortRaw

+ const GvHasPosUS

+ const GvHasPosUSPrev

+ const GvHasRew

+ const GvHasRewPrev

+ const GvLHbBurst

+ const GvLHbDip

+ const GvLHbDipSum

+ const GvLHbDipSumCur

+ const GvLHbGiveUp

+ const GvLHbNeg

+ const GvLHbPos

+ const GvNE

+ const GvNotMaint

+ const GvPrevPred

+ const GvRew

+ const GvRewPred

+ const GvSer

+ const GvUSneg

+ const GvUSpos

+ const GvUrgency

+ const GvUrgencyRaw

+ const GvVSMatrixHasGated

+ const GvVSMatrixJustGated

+ const GvVSPatch

+ const GvVtaCeMneg

+ const GvVtaCeMpos

+ const GvVtaDA

+ const GvVtaLHbBurst

+ const GvVtaLHbDip

+ const GvVtaPVneg

+ const GvVtaPVpos

+ const GvVtaUSpos

+ const GvVtaVSPatchPos

+ func (ev *GlobalVars) UnmarshalJSON(b []byte) error

+ func (ev GlobalVars) MarshalJSON() ([]byte, error)

+ func (i *GlobalVars) FromString(s string) error

+ func (i GlobalVars) String() string

type Layer

+ func (ly *Layer) DecayStateNeuronsAll(ctx *Context, decay, glong, ahp float32)

+ func (ly *Layer) InitActAvgLayer(ctx *Context)

+ func (ly *Layer) InitActAvgPools(ctx *Context)

+ func (ly *Layer) NewStateNeurons(ctx *Context)

+ func (ly *Layer) PlusPhaseActAvg(ctx *Context)

+ func (ly *Layer) TestVals(ctrKey string, vals map[string]float32)

type LayerBase

+ MaxData uint32

+ NNeurons uint32

+ Vals []LayerVals

+ func (ly *LayerBase) LayerVals(di uint32) *LayerVals

+ func (ly *LayerBase) RecvPrjnVals(vals *[]float32, varNm string, sendLay emer.Layer, sendIdx1D int, ...) error

+ func (ly *LayerBase) SendPrjnVals(vals *[]float32, varNm string, recvLay emer.Layer, recvIdx1D int, ...) error

+ func (ly *LayerBase) SubPool(ctx *Context, ni, di uint32) *Pool

+ func (ly *LayerBase) UnitVal(varNm string, idx []int, di int) float32

+ func (ly *LayerBase) UnitVal1D(varIdx int, idx, di int) float32

+ func (ly *LayerBase) UnitVals(vals *[]float32, varNm string, di int) error

+ func (ly *LayerBase) UnitValsRepTensor(tsr etensor.Tensor, varNm string, di int) error

+ func (ly *LayerBase) UnitValsTensor(tsr etensor.Tensor, varNm string, di int) error

+ func (ly *LayerBase) UnitVarIdx(varNm string) (int, error)

+ func (ly *LayerBase) UnitVarNames() []string

+ func (ly *LayerBase) UnitVarNum() int

+ func (ly *LayerBase) UnitVarProps() map[string]string

type LayerIdxs

+ LayIdx uint32

+ MaxData uint32

+ func (lx *LayerIdxs) ExtIdx(ni, di uint32) uint32

+ func (lx *LayerIdxs) PoolIdx(pi, di uint32) uint32

+ func (lx *LayerIdxs) ValsIdx(di uint32) uint32

type LayerParams

+ Acts ActParams

+ Bursts BurstParams

+ func (ly *LayerParams) CyclePostLayer(ctx *Context, di uint32, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) NewStateLayerActAvg(ctx *Context, vals *LayerVals, actMinusAvg, actPlusAvg float32)

type LayerVals

+ DataIdx uint32

+ LayIdx uint32

+ RT float32

type LearnNeurParams

+ CaLearn CaLrnParams

+ type NetIdxs struct

+ GvDriveOff uint32

+ GvDriveStride uint32

+ GvUSnegOff uint32

+ GvVTAOff uint32

+ GvVTAStride uint32

+ MaxData uint32

+ NData uint32

+ NLayers uint32

+ NNeurons uint32

+ NPools uint32

+ NSyns uint32

+ NetIdx uint32

+ func (ctx *NetIdxs) DataIdx(idx uint32) uint32

+ func (ctx *NetIdxs) DataIdxIsValid(li uint32) bool

+ func (ctx *NetIdxs) ItemIdx(idx uint32) uint32

+ func (ctx *NetIdxs) LayerIdxIsValid(li uint32) bool

+ func (ctx *NetIdxs) NeurIdxIsValid(ni uint32) bool

+ func (ctx *NetIdxs) PoolDataIdxIsValid(pi uint32) bool

+ func (ctx *NetIdxs) PoolIdxIsValid(pi uint32) bool

+ func (ctx *NetIdxs) SynIdxIsValid(si uint32) bool

+ func (ctx *NetIdxs) ValsIdx(li, di uint32) uint32

type Network

+ func (nt *Network) InitName(net emer.Network, name string)

+ func (nt *Network) NeuronsSlice(vals *[]float32, nrnVar string, di int)

+ func (nt *Network) SynsSlice(vals *[]float32, synvar SynapseVars)

type NetworkBase

+ Ctx Context

+ Globals []float32

+ MaxData uint32

+ NData uint32

+ NNeurons uint32

+ NSyns uint32

+ NetIdx uint32

+ NeuronAvgs []float32

+ NeuronIxs []uint32

+ SynapseCas []float32

+ SynapseIxs []uint32

+ UseGPUOrder bool

+ func (nt *NetworkBase) AllGlobalVals(ctrKey string, vals map[string]float32)

+ func (nt *NetworkBase) AllGlobals() string

+ func (nt *NetworkBase) BuildGlobals(ctx *Context)

+ func (nt *NetworkBase) LayerVals(li, di uint32) *LayerVals

+ func (nt *NetworkBase) MaxParallelData() int

+ func (nt *NetworkBase) NParallelData() int

+ func (nt *NetworkBase) SetCtxStrides(simCtx *Context)

+ func (nt *NetworkBase) SetMaxData(simCtx *Context, maxData int)

+ func (nt *NetworkBase) SynVarNames() []string

+ func (nt *NetworkBase) SynVarProps() map[string]string

+ func (nt *NetworkBase) UnitVarNames() []string

+ func (nt *NetworkBase) UnitVarProps() map[string]string

+ type NeuronAvgVarStrides struct

+ Neuron uint32

+ Var uint32

+ func (ns *NeuronAvgVarStrides) Idx(neurIdx uint32, nvar NeuronAvgVars) uint32

+ func (ns *NeuronAvgVarStrides) SetNeuronOuter()

+ func (ns *NeuronAvgVarStrides) SetVarOuter(nneur int)

+ type NeuronAvgVars int32

+ const AvgDif

+ const AvgPct

+ const DTrgAvg

+ const GeBase

+ const GiBase

+ const NeuronAvgVarsN

+ const TrgAvg

+ func (ev *NeuronAvgVars) UnmarshalJSON(b []byte) error

+ func (ev NeuronAvgVars) MarshalJSON() ([]byte, error)

+ func (i *NeuronAvgVars) FromString(s string) error

+ func (i NeuronAvgVars) String() string

+ type NeuronIdxStrides struct

+ Index uint32

+ Neuron uint32

+ func (ns *NeuronIdxStrides) Idx(neurIdx uint32, idx NeuronIdxs) uint32

+ func (ns *NeuronIdxStrides) SetIdxOuter(nneur int)

+ func (ns *NeuronIdxStrides) SetNeuronOuter()

+ type NeuronIdxs int32

+ const NeuronIdxsN

+ const NrnLayIdx

+ const NrnNeurIdx

+ const NrnSubPool

+ func (ev *NeuronIdxs) UnmarshalJSON(b []byte) error

+ func (ev NeuronIdxs) MarshalJSON() ([]byte, error)

+ func (i *NeuronIdxs) FromString(s string) error

+ func (i NeuronIdxs) String() string

+ type NeuronVarStrides struct

+ Neuron uint32

+ Var uint32

+ func (ns *NeuronVarStrides) Idx(neurIdx, di uint32, nvar NeuronVars) uint32

+ func (ns *NeuronVarStrides) SetNeuronOuter(ndata int)

+ func (ns *NeuronVarStrides) SetVarOuter(nneur, ndata int)

type NeuronVars

+ const Act

+ const ActInt

+ const ActM

+ const ActP

+ const Attn

+ const Burst

+ const BurstPrv

+ const CaDiff

+ const CaLrn

+ const CaSpkD

+ const CaSpkM

+ const CaSpkP

+ const CaSpkPM

+ const CaSyn

+ const CtxtGe

+ const CtxtGeOrig

+ const CtxtGeRaw

+ const Ext

+ const GABAB

+ const GABABx

+ const GMaintRaw

+ const GMaintSyn

+ const GModRaw

+ const GModSyn

+ const Gak

+ const Ge

+ const GeExt

+ const GeInt

+ const GeIntMax

+ const GeNoiseP

+ const GeRaw

+ const GeSyn

+ const GgabaB

+ const Gi

+ const GiInt

+ const GiNoise

+ const GiNoiseP

+ const GiRaw

+ const GiSyn

+ const Gk

+ const GknaMed

+ const GknaSlow

+ const Gnmda

+ const GnmdaLrn

+ const GnmdaMaint

+ const GnmdaSyn

+ const Gsk

+ const Gvgcc

+ const ISI

+ const ISIAvg

+ const Inet

+ const MahpN

+ const NeuronVarsN

+ const NmdaCa

+ const NrnCaD

+ const NrnCaM

+ const NrnCaP

+ const NrnFlags

+ const RLRate

+ const SKCaIn

+ const SKCaM

+ const SKCaR

+ const SSGi

+ const SSGiDend

+ const SahpCa

+ const SahpN

+ const Spike

+ const Spiked

+ const SpkMax

+ const SpkMaxCa

+ const SpkPrv

+ const SpkSt1

+ const SpkSt2

+ const Target

+ const VgccCa

+ const VgccCaInt

+ const VgccH

+ const VgccM

+ const Vm

+ const VmDend

+ func (ev *NeuronVars) UnmarshalJSON(b []byte) error

+ func (ev NeuronVars) MarshalJSON() ([]byte, error)

+ func (i *NeuronVars) FromString(s string) error

+ func (i NeuronVars) String() string

type Pool

+ DataIdx uint32

+ func (pl *Pool) AvgMaxUpdate(ctx *Context, ni, di uint32)

+ func (pl *Pool) TestVals(layKey string, vals map[string]float32)

type Prjn

+ func (pj *Prjn) InitSynCa(ctx *Context, syni, di uint32)

+ func (pj *Prjn) SynCaReset(ctx *Context)

type PrjnBase

+ NSyns uint32

+ SynStIdx uint32

+ func (pj *PrjnBase) SynVal1DDi(varIdx int, synIdx int, di int) float32

+ func (pj *PrjnBase) SynValDi(varNm string, sidx, ridx int, di int) float32

type PrjnParams

+ SWts SWtParams

+ func (pj *PrjnParams) DWtFmDiDWtSyn(ctx *Context, syni uint32)

+ type SynapseCaStrides struct

+ Synapse uint32

+ Var uint32

+ func (ns *SynapseCaStrides) Idx(synIdx, di uint32, nvar SynapseCaVars) uint64

+ func (ns *SynapseCaStrides) SetSynapseOuter(ndata int)

+ func (ns *SynapseCaStrides) SetVarOuter(nsyn, ndata int)

+ type SynapseCaVars int32

+ const CaD

+ const CaM

+ const CaP

+ const CaUpT

+ const DTr

+ const DiDWt

+ const SynapseCaVarsN

+ const Tr

+ func (ev *SynapseCaVars) UnmarshalJSON(b []byte) error

+ func (ev SynapseCaVars) MarshalJSON() ([]byte, error)

+ func (i *SynapseCaVars) FromString(s string) error

+ func (i SynapseCaVars) String() string

+ type SynapseIdxStrides struct

+ Index uint32

+ Synapse uint32

+ func (ns *SynapseIdxStrides) Idx(synIdx uint32, idx SynapseIdxs) uint32

+ func (ns *SynapseIdxStrides) SetIdxOuter(nsyn int)

+ func (ns *SynapseIdxStrides) SetSynapseOuter()

+ type SynapseIdxs int32

+ const SynPrjnIdx

+ const SynRecvIdx

+ const SynSendIdx

+ const SynapseIdxsN

+ func (ev *SynapseIdxs) UnmarshalJSON(b []byte) error

+ func (ev SynapseIdxs) MarshalJSON() ([]byte, error)

+ func (i *SynapseIdxs) FromString(s string) error

+ func (i SynapseIdxs) String() string

+ type SynapseVarStrides struct

+ Synapse uint32

+ Var uint32

+ func (ns *SynapseVarStrides) Idx(synIdx uint32, nvar SynapseVars) uint64

+ func (ns *SynapseVarStrides) SetSynapseOuter()

+ func (ns *SynapseVarStrides) SetVarOuter(nsyn int)

type SynapseVars

+ const DSWt

+ const DWt

+ const LWt

+ const SWt

+ const SynapseVarsN

+ const Wt

+ func (ev *SynapseVars) UnmarshalJSON(b []byte) error

+ func (ev SynapseVars) MarshalJSON() ([]byte, error)

+ func (i *SynapseVars) FromString(s string) error

+ func (i SynapseVars) String() string

May 17, 2023

Changes in this version

type Context

+ func (ctx *Context) PVLVInitUS()

May 16, 2023

Changes in this version

+ func ParallelChunkRun(fun func(st, ed int), total int, nThreads int)

+ func ParallelRun(fun func(st, ed int), total int, nThreads int)

type NetworkBase

+ RecvPrjnIdxs []uint32

+ RecvSynIdxs []uint32

+ func (nt *NetworkBase) LayerMapPar(fun func(ly *Layer), funame string)

+ func (nt *NetworkBase) NeuronMapPar(fun func(ly *Layer, ni uint32, nrn *Neuron), funame string)

+ func (nt *NetworkBase) NeuronMapSeq(fun func(ly *Layer, ni uint32, nrn *Neuron), funame string)

+ func (nt *NetworkBase) SetNThreads(nthr int)

type PrjnBase

+ func (pj *PrjnBase) RecvSynIdxs(ri int) []uint32

+ func (pj *PrjnBase) SendSyns(si int) []Synapse

type PrjnParams

+ func (pj *PrjnParams) SynCaSyn(ctx *Context, sy *Synapse, nrn *Neuron, otherCaSyn, updtThr float32)

May 8, 2023

Changes in this version

type Drives

+ func (dp *Drives) EffectiveDrive(i int32) float32

May 8, 2023

Changes in this version

type LHb

+ DipSumCur float32

May 5, 2023

Changes in this version

type ActParams

+ MaintNMDA chans.NMDAParams

+ func (ac *ActParams) MaintNMDAFmRaw(nrn *Neuron)

type Context

+ func (ctx *Context) PVLVShouldGiveUp(rnd erand.Rand)

+ func (ctx *Context) PVLVStepStart(rnd erand.Rand)

type DendParams

+ ModBase float32

type Effort

+ MaxVar float32

+ func (ef *Effort) GiveUp() bool

+ func (ef *Effort) PlusVar(rnd erand.Rand, max float32) float32

+ func (ef *Effort) ReStart(rnd erand.Rand)

type LDTParams

+ SrcThr float32

+ func (lp *LDTParams) ACh(ctx *Context, srcLay1Act, srcLay2Act, srcLay3Act, srcLay4Act float32) float32

+ func (lp *LDTParams) MaxSrcAct(maxSrcAct, srcLayAct float32) float32

type LHb

+ GiveUp slbool.Bool

+ GiveUpThr float32

+ func (lh *LHb) ShouldGiveUp() bool

type Layer

+ func (ly *Layer) LDTSrcLayAct(net *Network, layIdx int32) float32

type Neuron

+ GMaintRaw float32

+ GMaintSyn float32

+ GnmdaMaint float32

type PVLV

+ func (pp *PVLV) ShouldGiveUp(rnd erand.Rand, hasRew bool) bool

type PrjnGTypes

+ const MaintG

type Urgency

+ Thr float32

May 1, 2023

Changes in this version

type ActParams

+ func (ac *ActParams) DecayAHP(nrn *Neuron, decay float32)

+ func (ac *ActParams) KNaNewState(ctx *Context, nrn *Neuron)

+ type BLAPrjnParams struct

+ NegDeltaLRate float32

+ func (bp *BLAPrjnParams) Defaults()

+ func (bp *BLAPrjnParams) Update()

type Context

+ func (ctx *Context) PVLVSetDrives(curiosity, magnitude float32, drives ...int)

+ func (ctx *Context) PVLVSetUS(hasUS, isPos bool, usIdx int, magnitude float32)

type Effort

+ CurMax float32

+ Max float32

+ MaxNovel float32

+ MaxPostDip float32

+ type LDTParams struct

+ MaintInhib float32

+ NotMaintMax float32

+ Rew slbool.Bool

+ RewPred slbool.Bool

+ RewThr float32

+ SrcLay1Idx int32

+ SrcLay2Idx int32

+ SrcLay3Idx int32

+ SrcLay4Idx int32

+ func (lp *LDTParams) Defaults()

+ func (lp *LDTParams) MaintFmNotMaint(notMaint float32) float32

+ func (lp *LDTParams) Thr(val float32) float32

+ func (lp *LDTParams) Update()

type LHb

+ DipLowThr float32

+ func (lh *LHb) Reset()

type Layer

+ func (ly *Layer) BGThalDefaults()

+ func (ly *Layer) CTDefParamsFast()

+ func (ly *Layer) CTDefParamsLong()

+ func (ly *Layer) CTDefParamsMedium()

+ func (ly *Layer) DecayStateAHP(ctx *Context, decay, glong, ahp float32)

+ func (ly *Layer) LDTDefaults()

+ func (ly *Layer) LDTLayMaxAct(net *Network, layIdx int32) float32

+ func (ly *Layer) LDTPostBuild()

type LayerBase

+ DefParams params.Params

+ func (ly *LayerBase) ApplyDefParams()

type LayerParams

+ LDT LDTParams

+ func (ly *LayerParams) CyclePostCeMLayer(ctx *Context, lpl *Pool)

+ func (ly *LayerParams) CyclePostLDTLayer(ctx *Context, vals *LayerVals, ...)

+ func (ly *LayerParams) CyclePostPTNotMaintLayer(ctx *Context, lpl *Pool)

+ func (ly *LayerParams) LDTMaxLayAct(maxAct, layMaxAct float32) float32

+ func (ly *LayerParams) UrgencyDefaults()

type LayerTypes

+ const BGThalLayer

+ const LDTLayer

+ const UrgencyLayer

type Network

+ func (net *Network) AddBGThalLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (net *Network) AddBGThalLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (net *Network) AddBOA(ctx *Context, nUSneg, nYneur, popY, popX, bgY, bgX, pfcY, pfcX int, ...) (...)

+ func (net *Network) AddLDTLayer(prefix string) *Layer

+ func (net *Network) AddOFCus(ctx *Context, nUSs, nY, ofcY, ofcX int, space float32) (ofc, ofcCT, ofcPT, ofcPTp, ofcMD, notMaint *Layer)

+ func (net *Network) AddPFC2D(name, thalSuffix string, nNeurY, nNeurX int, decayOnRew bool, space float32) (pfc, pfcCT, pfcPT, pfcPTp, pfcThal *Layer)

+ func (net *Network) AddPFC4D(name, thalSuffix string, nPoolsY, nPoolsX, nNeurY, nNeurX int, decayOnRew bool, ...) (pfc, pfcCT, pfcPT, pfcPTp, pfcThal *Layer)

+ func (net *Network) AddPVLVOFCus(ctx *Context, nUSneg, nYneur, popY, popX, bgY, bgX, ofcY, ofcX int, ...) (...)

+ func (net *Network) AddPVLVPulvLayers(ctx *Context, nUSneg, nYneur, popY, popX int, space float32) (...)

+ func (net *Network) AddSCLayer2D(prefix string, nNeurY, nNeurX int) *Layer

+ func (net *Network) AddSCLayer4D(prefix string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (net *Network) AddUrgencyLayer(nNeurY, nNeurX int) *Layer

+ func (net *Network) AddUrgencyPulvLayer(nNeurY, nNeurX int, space float32) (urge, urgeP *Layer)

+ func (net *Network) AddVS(nUSs, nNeurY, nNeurX, nY int, space float32) (vSmtxGo, vSmtxNo, vSstnp, vSstns, vSgpi, vSpatch, vSgated *Layer)

+ func (net *Network) AddVTALHbLDTLayers(rel relpos.Relations, space float32) (vta, lhb, ldt *Layer)

+ func (net *Network) ConnectCSToBLAPos(cs, blaAcq, blaNov *Layer) (toAcq, toNov *Prjn)

+ func (net *Network) ConnectToPFC(lay, layP, pfc, pfcCT, pfcPTp *Layer, pat prjn.Pattern)

+ func (net *Network) ConnectToPFCBack(lay, layP, pfc, pfcCT, pfcPTp *Layer, pat prjn.Pattern)

+ func (net *Network) ConnectToPFCBidir(lay, layP, pfc, pfcCT, pfcPTp *Layer, pat prjn.Pattern) (ff, fb *Prjn)

+ func (net *Network) ConnectToSC(send, recv *Layer, pat prjn.Pattern) *Prjn

+ func (net *Network) ConnectToSC1to1(send, recv *Layer) *Prjn

+ func (net *Network) ConnectUSToBLAPos(us, blaAcq, blaExt *Layer) (toAcq, toExt *Prjn)

type NeuroModParams

+ func (nm *NeuroModParams) IsBLAExt() bool

type NeuroModVals

+ NotMaint float32

type Neuron

+ GeIntMax float32

type PVLV

+ HasPosUSPrev slbool.Bool

+ HasRewPrev slbool.Bool

+ Urgency Urgency

+ func (pp *PVLV) EffortUrgencyUpdt(effort float32)

+ func (pp *PVLV) NetPV() float32

+ func (pp *PVLV) NewState(hasRew bool)

+ func (pp *PVLV) Reset()

+ func (pp *PVLV) USStimVal(usIdx int32, valence ValenceTypes) float32

+ func (pp *PVLV) UrgencyUpdt(effort float32)

+ func (pp *PVLV) VSGated(gated, hasRew bool, poolIdx int)

type PoolAvgMax

+ GeIntMax AvgMaxPhases

type PrjnBase

+ DefParams params.Params

+ func (pj *PrjnBase) ApplyDefParams()

type PrjnParams

+ BLA BLAPrjnParams

+ func (pj *PrjnParams) BLADefaults()

+ func (pj *PrjnParams) CTCtxtPrjnDefaults()

+ func (pj *PrjnParams) DWtSynBLA(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool)

+ func (pj *PrjnParams) RLPredDefaults()

+ func (pj *PrjnParams) VSPatchDefaults()

type TraceParams

+ LearnThr float32

+ type Urgency struct

+ Power int32

+ Raw float32

+ U50 float32

+ Urge float32

+ func (ur *Urgency) AddEffort(inc float32)

+ func (ur *Urgency) Defaults()

+ func (ur *Urgency) Reset()

+ func (ur *Urgency) Update()

+ func (ur *Urgency) UrgeFmUrgency() float32

+ func (ur *Urgency) UrgeFun(urgency float32) float32

type VSMatrix

+ func (vt *VSMatrix) NewState(hasRew bool)

type VTA

+ func (vt *VTA) Reset()

type VTAVals

+ CeMneg float32

+ CeMpos float32

+ USpos float32

Apr 5, 2023

Changes in this version

type ActParams

+ func (ac *ActParams) DecayLearnCa(nrn *Neuron, decay float32)

type DecayParams

+ LearnCa float32

type NeuroModParams

+ func (nm *NeuroModParams) DASign() float32

type Neuron

+ DASign float32

+ SKCaIn float32

+ SKCaR float32

Mar 31, 2023

Changes in this version

+ func HashEncodeSlice(slice []float32) string

type Network

+ func (nt *Network) WtsHash() string

+ func (nt *Network) WtsSlice(wts *[]float32)

Mar 29, 2023

Changes in this version

type Context

+ CyclesTotal int32

+ TimePerCycle float32

+ TrialsTotal int32

type Effort

+ func (ef *Effort) DiscFun(effort float32) float32

type PVLV

+ func (pp *PVLV) PosPVFmDriveEffort(usValue, drive, effort float32) float32

Mar 28, 2023

Changes in this version

type Context

+ func (ctx *Context) PVLVDA() float32

type LayerParams

+ func (ly *LayerParams) CyclePostPPTgLayer(ctx *Context, lpl *Pool)

+ func (ly *LayerParams) CyclePostVSPatchLayer(ctx *Context, pi int32, pl *Pool)

+ func (ly *LayerParams) CyclePostVTALayer(ctx *Context)

type NetworkBase

+ Rand erand.SysRand

+ RndSeed int64

+ func (nt *NetworkBase) AxonLayerByName(name string) *Layer

+ func (nt *NetworkBase) LayByNameTry(name string) (*Layer, error)

+ func (nt *NetworkBase) ResetRndSeed()

+ func (nt *NetworkBase) SetRndSeed(seed int64)

Mar 23, 2023

Changes in this version

+ const CyclesN

+ var KiT_ValenceTypes = kit.Enums.AddEnum(ValenceTypesN, kit.NotBitFlag, nil)

+ func LayerActsLog(net *Network, lg *elog.Logs, gui *egui.GUI)

+ func LayerActsLogAvg(net *Network, lg *elog.Logs, gui *egui.GUI, recReset bool)

+ func LayerActsLogConfig(net *Network, lg *elog.Logs)

+ func LayerActsLogConfigGUI(lg *elog.Logs, gui *egui.GUI)

+ func LayerActsLogConfigMetaData(dt *etable.Table)

+ func LayerActsLogRecReset(lg *elog.Logs)

type ActParams

+ PopCode PopCodeParams

type AvgMaxPhases

+ Prev AvgMaxI32

+ type BLAAcqPrjnParams struct

+ NegDeltaLRate float32

+ NonUSLRate float32

+ func (bp *BLAAcqPrjnParams) Defaults()

+ func (bp *BLAAcqPrjnParams) Update()

type Context

+ PVLV PVLV

+ TrialsTot int32

+ func (ctx *Context) DA() float32

+ func (ctx *Context) LHbDipResetFmSum()

+ func (ctx *Context) NeuroModFmPVLV()

type DecayParams

+ OnRew slbool.Bool

+ type DriveVals struct

+ D0 float32

+ D1 float32

+ D2 float32

+ D3 float32

+ D4 float32

+ D5 float32

+ D6 float32

+ D7 float32

+ func (ds *DriveVals) Add(drv int32, delta float32) float32

+ func (ds *DriveVals) ExpStep(drv int32, dt, base float32) float32

+ func (ds *DriveVals) Get(drv int32) float32

+ func (ds *DriveVals) Set(drv int32, val float32)

+ func (ds *DriveVals) SetAll(val float32)

+ func (ds *DriveVals) SoftAdd(drv int32, delta float32) float32

+ func (ds *DriveVals) Zero()

+ type Drives struct

+ Base DriveVals

+ DriveMin float32

+ Drives DriveVals

+ Dt DriveVals

+ NActive int32

+ NNegUSs int32

+ Tau DriveVals

+ USDec DriveVals

+ func (dp *Drives) Defaults()

+ func (dp *Drives) ExpStep()

+ func (dp *Drives) ToBaseline()

+ func (dp *Drives) ToZero()

+ func (dp *Drives) Update()

+ type Effort struct

+ Disc float32

+ Gain float32

+ PrevDisc float32

+ Raw float32

+ func (ef *Effort) AddEffort(inc float32)

+ func (ef *Effort) Defaults()

+ func (ef *Effort) DiscFmEffort() float32

+ func (ef *Effort) Reset()

+ func (ef *Effort) Update()

type GPU

+ func (gp *GPU) RunApplyExtsCmd() vk.CommandBuffer

+ func (gp *GPU) RunCycleOneCmd() vk.CommandBuffer

+ func (gp *GPU) RunCyclesCmd() vk.CommandBuffer

+ func (gp *GPU) RunMinusPhaseCmd() vk.CommandBuffer

+ func (gp *GPU) RunPipelineCmd(cmd vk.CommandBuffer, name string, n int, wait, signal string)

+ func (gp *GPU) RunPlusPhaseCmd() vk.CommandBuffer

+ func (gp *GPU) RunWtFmDWtCmd() vk.CommandBuffer

+ func (gp *GPU) StartRunCmd(cmd vk.CommandBuffer)

+ type LHb struct

+ Burst float32

+ Dip float32

+ DipReset slbool.Bool

+ DipResetThr float32

+ DipSum float32

+ Neg float32

+ NegGain float32

+ Pos float32

+ PosGain float32

+ func (lh *LHb) Defaults()

+ func (lh *LHb) DipResetFmSum(resetSum bool) bool

+ func (lh *LHb) LHbFmPVVS(pvPos, pvNeg, vsPatchPos float32)

+ func (lh *LHb) Update()

type Layer

+ func (ly *Layer) BLADefaults()

+ func (ly *Layer) CeMDefaults()

+ func (ly *Layer) PPTgDefaults()

+ func (ly *Layer) PTNotMaintDefaults()

+ func (ly *Layer) PVLVPostBuild()

type LayerBase

+ ParamsHistory params.HistoryImpl

+ func (ly *LayerBase) ParamsApplied(sel *params.Sel)

+ func (ly *LayerBase) ParamsHistoryReset()

+ func (ly *LayerBase) PlaceAbove(other *Layer)

+ func (ly *LayerBase) PlaceBehind(other *Layer, space float32)

+ func (ly *LayerBase) PlaceRightOf(other *Layer, space float32)

type LayerIdxs

+ ShpPlX int32

+ ShpPlY int32

+ ShpUnX int32

+ ShpUnY int32

type LayerParams

+ PVLV PVLVParams

+ VSPatch VSPatchParams

+ func (ly *LayerParams) DrivesDefaults()

+ func (ly *LayerParams) EffortDefaults()

+ func (ly *LayerParams) PTPredDefaults()

+ func (ly *LayerParams) PVDefaults()

+ func (ly *LayerParams) PlusPhaseNeuronSpecial(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) USDefaults()

+ func (ly *LayerParams) VSGatedDefaults()

+ func (ly *LayerParams) VSPatchDefaults()

type LayerTypes

+ const DrivesLayer

+ const EffortLayer

+ const LHbLayer

+ const PTNotMaintLayer

+ const PTPredLayer

+ const PVLayer

+ const USLayer

+ const VSGatedLayer

+ const VSPatchLayer

+ const VTALayer

type MatrixParams

+ IsVS slbool.Bool

+ ThalLay6Idx int32

type Network

+ func (nt *Network) AddDrivePVLVPulvLayers(ctx *Context, nUSneg, nYunits, popY, popX int, space float32) (...)

+ func (nt *Network) AddDrivesLayer(ctx *Context, unY, unX int) *Layer

+ func (nt *Network) AddDrivesPulvLayer(ctx *Context, unY, unX int, space float32) (drv, drvP *Layer)

+ func (nt *Network) AddEffortLayer(unY, unX int) *Layer

+ func (nt *Network) AddEffortPulvLayer(unY, unX int, space float32) (eff, effP *Layer)

+ func (nt *Network) AddPTNotMaintLayer(ptMaint *Layer, nNeurY, nNeurX int, space float32) *Layer

+ func (nt *Network) AddPTPredLayer(ptMaint, ct, thal *Layer, ptToPredPrjn, ctToPredPrjn, toThalPrjn prjn.Pattern, ...) (ptPred *Layer)

+ func (nt *Network) AddPTPredLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddPTPredLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddPVLayers(unY, unX int, rel relpos.Relations, space float32) (pvPos, pvNeg *Layer)

+ func (nt *Network) AddPVPulvLayers(unY, unX int, rel relpos.Relations, space float32) (pvPos, pvNeg, pvPosP, pvNegP *Layer)

+ func (nt *Network) AddPulvForLayer(lay *Layer, space float32) *Layer

+ func (nt *Network) AddUSLayers(nUSpos, nUSneg, nYunits int, rel relpos.Relations, space float32) (usPos, usNeg *Layer)

+ func (nt *Network) AddUSPulvLayers(nUSpos, nUSneg, nYunits int, rel relpos.Relations, space float32) (usPos, usNeg, usPosP, usNegP *Layer)

+ func (nt *Network) AddVSGatedLayer(prefix string, nYunits int) *Layer

+ func (nt *Network) AddVSPatchLayer(prefix string, nUs, unY, unX int) *Layer

+ func (nt *Network) AddVTALHbAChLayers(rel relpos.Relations, space float32) (vta, lhb, ach *Layer)

+ func (nt *Network) ConnectPTNotMaint(ptMaint, ptNotMaint emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectPTPredSelf(ly emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectPTPredToPulv(ptPred, pulv emer.Layer, toPulvPat, fmPulvPat prjn.Pattern) (toPulv, toPTPred emer.Prjn)

+ func (nt *Network) ConnectToBLAAcq(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectToBLAExt(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectToVSPatch(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

type NetworkBase

+ func (nt *NetworkBase) AllLayerInhibs() string

+ func (nt *NetworkBase) KeyLayerParams() string

+ func (nt *NetworkBase) KeyPrjnParams() string

+ func (nt *NetworkBase) ParamsApplied(sel *params.Sel)

+ func (nt *NetworkBase) ParamsHistoryReset()

type NeuroModParams

+ DALRateSign slbool.Bool

+ Valence ValenceTypes

+ func (nm *NeuroModParams) DAGain(da float32) float32

type NeuroModVals

+ PPTg float32

type Neuron

+ CtxtGeOrig float32

+ GeInt float32

+ GiInt float32

+ type PVLV struct

+ Drive Drives

+ Effort Effort

+ LHb LHb

+ USneg DriveVals

+ USpos DriveVals

+ VSMatrix VSMatrix

+ VSPatch DriveVals

+ VTA VTA

+ func (pp *PVLV) DA(pptg float32) float32

+ func (pp *PVLV) Defaults()

+ func (pp *PVLV) DriveEffortUpdt(effort float32, hasRew, resetUs bool)

+ func (pp *PVLV) DriveUpdt(resetUs bool)

+ func (pp *PVLV) EffortUpdt(effort float32, hasRew bool)

+ func (pp *PVLV) HasNegUS() bool

+ func (pp *PVLV) HasPosUS() bool

+ func (pp *PVLV) InitDrives()

+ func (pp *PVLV) InitUS()

+ func (pp *PVLV) LHbDipResetFmSum() bool

+ func (pp *PVLV) NegPV() float32

+ func (pp *PVLV) PosPV() float32

+ func (pp *PVLV) SetDrive(dr int32, val float32)

+ func (pp *PVLV) SetNegUS(usn int32, val float32)

+ func (pp *PVLV) SetPosUS(usn int32, val float32)

+ func (pp *PVLV) Update()

+ func (pp *PVLV) VSPatchMax() float32

+ type PVLVParams struct

+ Gain float32

+ Thr float32

+ func (pp *PVLVParams) Defaults()

+ func (pp *PVLVParams) Update()

+ func (pp *PVLVParams) Val(val float32) float32

type PoolAvgMax

+ GeInt AvgMaxPhases

+ GiInt AvgMaxPhases

+ type PopCodeParams struct

+ Clip slbool.Bool

+ Ge float32

+ Max float32

+ MaxSigma float32

+ Min float32

+ MinAct float32

+ MinSigma float32

+ On slbool.Bool

+ func (pc *PopCodeParams) ClipVal(val float32) float32

+ func (pc *PopCodeParams) Defaults()

+ func (pc *PopCodeParams) EncodeGe(i, n uint32, val float32) float32

+ func (pc *PopCodeParams) EncodeVal(i, n uint32, val float32) float32

+ func (pc *PopCodeParams) ProjectParam(minParam, maxParam, clipVal float32) float32

+ func (pc *PopCodeParams) SetRange(min, max, minSigma, maxSigma float32)

+ func (pc *PopCodeParams) Update()

type PrjnBase

+ ParamsHistory params.HistoryImpl

+ func (pj *PrjnBase) ParamsApplied(sel *params.Sel)

+ func (pj *PrjnBase) ParamsHistoryReset()

type PrjnParams

+ BLAAcq BLAAcqPrjnParams

+ func (pj *PrjnParams) BLAAcqPrjnDefaults()

+ func (pj *PrjnParams) BLAExtPrjnDefaults()

+ func (pj *PrjnParams) DWtSynBLAAcq(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool)

+ func (pj *PrjnParams) DWtSynBLAExt(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool)

+ func (pj *PrjnParams) DWtSynVSPatch(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool)

+ func (pj *PrjnParams) DoSynCa() bool

+ func (pj *PrjnParams) MatrixDefaults()

+ func (pj *PrjnParams) SetFixedWts()

+ func (pj *PrjnParams) VSPatchPrjnDefaults()

type PrjnTypes

+ const BLAAcqPrjn

+ const BLAExtPrjn

+ const VSPatchPrjn

type RSalAChParams

+ PPTg slbool.Bool

+ type VSMatrix struct

+ HasGated slbool.Bool

+ JustGated slbool.Bool

+ func (vt *VSMatrix) Defaults()

+ func (vt *VSMatrix) Reset()

+ func (vt *VSMatrix) Update()

+ func (vt *VSMatrix) VSGated(gated, hasRew bool)

+ type VSPatchParams struct

+ NoDALRate float32

+ NoDAThr float32

+ func (pp *VSPatchParams) DALRate(da, modlr float32) float32

+ func (pp *VSPatchParams) Defaults()

+ func (pp *VSPatchParams) Update()

+ type VTA struct

+ Gain VTAVals

+ PVThr float32

+ Prev VTAVals

+ Raw VTAVals

+ Vals VTAVals

+ func (vt *VTA) DAFmRaw()

+ func (vt *VTA) Defaults()

+ func (vt *VTA) Update()

+ type VTAVals struct

+ DA float32

+ LHbBurst float32

+ LHbDip float32

+ PPTg float32

+ PVneg float32

+ PVpos float32

+ VSPatchPos float32

+ func (vt *VTAVals) Set(pvPos, pvNeg, pptg, lhbDip, lhbBurst, vsPatchPos float32)

+ func (vt *VTAVals) SetAll(val float32)

+ func (vt *VTAVals) Zero()

+ type ValenceTypes int32

+ const Negative

+ const Positive

+ const ValenceTypesN

+ func (i *ValenceTypes) FromString(s string) error

+ func (i ValenceTypes) String() string

Feb 21, 2023

Changes in this version

type AxonLayer

+ MinusPhasePost func(ctx *Context)

+ PlusPhaseStart func(ctx *Context)

type AxonNetwork

+ PlusPhaseStartImpl func(ctx *Context)

type GPU

+ func (gp *GPU) RunPlusPhaseStart()

type Layer

+ func (ly *Layer) MinusPhasePost(ctx *Context)

+ func (ly *Layer) PlusPhaseStart(ctx *Context)

+ type LayerInhibIdxs struct

+ Idx1 int32

+ Idx2 int32

+ Idx3 int32

+ Idx4 int32

type LayerParams

+ LayInhib LayerInhibIdxs

+ func (ly *LayerParams) PlusPhaseStartNeuron(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, vals *LayerVals)

type Network

+ func (nt *Network) DecayStateLayers(ctx *Context, decay, glong float32, layers ...string)

+ func (nt *Network) PlusPhaseStart(ctx *Context)

+ func (nt *Network) PlusPhaseStartImpl(ctx *Context)

type NeuroModVals

+ func (nm *NeuroModVals) AChFmRaw(dt float32)

Feb 16, 2023

Changes in this version

+ var TheGPU *vgpu.GPU

+ func IsExtLayerType(lt LayerTypes) bool

type ActAvgVals

+ func (lv *ActAvgVals) Init()

+ type AvgMaxI32 struct

+ Avg float32

+ CurMax int32

+ Max float32

+ N int32

+ Sum int32

+ func (am *AvgMaxI32) Calc()

+ func (am *AvgMaxI32) FloatFmIntFactor() float32

+ func (am *AvgMaxI32) FloatFromInt(ival int32) float32

+ func (am *AvgMaxI32) FloatToInt(val float32) int32

+ func (am *AvgMaxI32) FloatToIntFactor() float32

+ func (am *AvgMaxI32) FloatToIntSum(val float32) int32

+ func (am *AvgMaxI32) Init()

+ func (am *AvgMaxI32) String() string

+ func (am *AvgMaxI32) UpdateVal(val float32)

+ func (am *AvgMaxI32) Zero()

type AvgMaxPhases

+ func (am *AvgMaxPhases) Calc()

+ func (am *AvgMaxPhases) Zero()

type AxonLayer

+ PlusPhasePost func(ctx *Context)

+ SynCaRecv func(ctx *Context, ni uint32, rn *Neuron)

+ SynCaSend func(ctx *Context, ni uint32, sn *Neuron)

type AxonPrjn

+ SynCaRecv func(ctx *Context, ni uint32, rn *Neuron, updtThr float32)

+ SynCaSend func(ctx *Context, ni uint32, sn *Neuron, updtThr float32)

type CaLrnParams

+ UpdtThr float32

type Context

+ NLayers int32

+ NSpiked int32

+ type GPU struct

+ Ctx *Context

+ CycleByCycle bool

+ DidBind map[string]bool

+ Exts *vgpu.VarSet

+ NThreads int

+ Net *Network

+ On bool

+ Params *vgpu.VarSet

+ Prjns *vgpu.VarSet

+ RecFunTimes bool

+ Semaphores map[string]vk.Semaphore

+ Structs *vgpu.VarSet

+ Sys *vgpu.System

+ func (gp *GPU) Config(ctx *Context, net *Network)

+ func (gp *GPU) CopyContextFmStaging()

+ func (gp *GPU) CopyContextToStaging()

+ func (gp *GPU) CopyExtsToStaging()

+ func (gp *GPU) CopyIdxsToStaging()

+ func (gp *GPU) CopyLayerStateFmStaging()

+ func (gp *GPU) CopyLayerValsFmStaging()

+ func (gp *GPU) CopyLayerValsToStaging()

+ func (gp *GPU) CopyNeuronsFmStaging()

+ func (gp *GPU) CopyNeuronsToStaging()

+ func (gp *GPU) CopyParamsToStaging()

+ func (gp *GPU) CopyPoolsFmStaging()

+ func (gp *GPU) CopyPoolsToStaging()

+ func (gp *GPU) CopyStateFmStaging()

+ func (gp *GPU) CopyStateToStaging()

+ func (gp *GPU) CopySynapsesFmStaging()

+ func (gp *GPU) CopySynapsesToStaging()

+ func (gp *GPU) Destroy()

+ func (gp *GPU) RunApplyExts()

+ func (gp *GPU) RunCycle()

+ func (gp *GPU) RunCycleOne()

+ func (gp *GPU) RunCycleSeparateFuns()

+ func (gp *GPU) RunCycles(ncyc int)

+ func (gp *GPU) RunDWt()

+ func (gp *GPU) RunMinusPhase()

+ func (gp *GPU) RunNewState()

+ func (gp *GPU) RunPipeline(name string, n int, wait, signal string)

+ func (gp *GPU) RunPipelineWait(name string, n int)

+ func (gp *GPU) RunPlusPhase()

+ func (gp *GPU) RunWtFmDWt()

+ func (gp *GPU) SetContext(ctx *Context)

+ func (gp *GPU) StartRun()

+ func (gp *GPU) SyncAllFmGPU()

+ func (gp *GPU) SyncAllToGPU()

+ func (gp *GPU) SyncContextFmGPU()

+ func (gp *GPU) SyncContextToGPU()

+ func (gp *GPU) SyncGBufToGPU()

+ func (gp *GPU) SyncLayerStateFmGPU()

+ func (gp *GPU) SyncLayerValsFmGPU()

+ func (gp *GPU) SyncLayerValsToGPU()

+ func (gp *GPU) SyncMemToGPU()

+ func (gp *GPU) SyncNeuronsFmGPU()

+ func (gp *GPU) SyncNeuronsToGPU()

+ func (gp *GPU) SyncParamsToGPU()

+ func (gp *GPU) SyncPoolsFmGPU()

+ func (gp *GPU) SyncPoolsToGPU()

+ func (gp *GPU) SyncRegionStruct(vnm string) vgpu.MemReg

+ func (gp *GPU) SyncStateFmGPU()

+ func (gp *GPU) SyncStateToGPU()

+ func (gp *GPU) SyncSynapsesFmGPU()

+ func (gp *GPU) SyncSynapsesToGPU()

type LaySpecialVals

+ func (lv *LaySpecialVals) Init()

type Layer

+ func (ly *Layer) ApplyExtVal(ni int, nrn *Neuron, val float32, clearMask, setMask NeuronFlags, toTarg bool)

+ func (ly *Layer) RSalAChLayMaxAct(net *Network, layIdx int32) float32

+ func (ly *Layer) SynCaRecv(ctx *Context, ni uint32, rn *Neuron)

+ func (ly *Layer) SynCaSend(ctx *Context, ni uint32, sn *Neuron)

type LayerBase

+ Exts []float32

+ func (ly *LayerBase) NSubPools() int

type LayerIdxs

+ ExtsSt uint32

type LayerParams

+ func (ly *LayerParams) ActAvgFmAct(ctx *Context, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) ApplyExtFlags(clearMask, setMask *NeuronFlags, toTarg *bool)

+ func (ly *LayerParams) ApplyExtVal(ni uint32, nrn *Neuron, val float32)

+ func (ly *LayerParams) AvgGeM(ctx *Context, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) CyclePostRSalAChLayer(ctx *Context, vals *LayerVals, ...)

+ func (ly *LayerParams) CyclePostRWDaLayer(ctx *Context, vals *LayerVals, pvals *LayerVals)

+ func (ly *LayerParams) CyclePostTDDaLayer(ctx *Context, vals *LayerVals, ivals *LayerVals)

+ func (ly *LayerParams) CyclePostTDIntegLayer(ctx *Context, vals *LayerVals, pvals *LayerVals)

+ func (ly *LayerParams) CyclePostTDPredLayer(ctx *Context, vals *LayerVals)

+ func (ly *LayerParams) InitExt(ni uint32, nrn *Neuron)

+ func (ly *LayerParams) IsInput() bool

+ func (ly *LayerParams) IsInputOrTarget() bool

+ func (ly *LayerParams) IsLearnTrgAvg() bool

+ func (ly *LayerParams) IsTarget() bool

+ func (ly *LayerParams) LearnTrgAvgErrLRate() float32

+ func (ly *LayerParams) MinusPhaseNeuron(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) MinusPhasePool(ctx *Context, pl *Pool)

+ func (ly *LayerParams) NewStateLayer(ctx *Context, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) NewStateNeuron(ctx *Context, ni uint32, nrn *Neuron, vals *LayerVals)

+ func (ly *LayerParams) NewStatePool(ctx *Context, pl *Pool)

+ func (ly *LayerParams) PlusPhaseNeuron(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) PlusPhasePool(ctx *Context, pl *Pool)

+ func (ly *LayerParams) RSalAChMaxLayAct(maxAct, layMaxAct float32) float32

type LayerTypes

+ func (lt LayerTypes) IsExt() bool

type LayerVals

+ func (lv *LayerVals) Init()

type Network

+ func (nt *Network) ApplyExts(ctx *Context)

+ func (nt *Network) ConfigGPUnoGUI(ctx *Context)

+ func (nt *Network) ConfigGPUwithGUI(ctx *Context)

type NetworkBase

+ Exts []float32

+ GPU GPU

+ Pools []Pool

+ PrjnRecvCon []StartN

+ PrjnSendCon []StartN

+ SendPrjnIdxs []uint32

+ SendSynIdxs []uint32

type NeuroModVals

+ func (nm *NeuroModVals) Init()

type PoolAvgMax

+ func (am *PoolAvgMax) Calc()

+ func (am *PoolAvgMax) SetN(n int32)

+ func (am *PoolAvgMax) Zero()

type Prjn

+ func (pj *Prjn) SynCaRecv(ctx *Context, ni uint32, rn *Neuron, updtThr float32)

+ func (pj *Prjn) SynCaSend(ctx *Context, ni uint32, sn *Neuron, updtThr float32)

type PrjnIdxs

+ RecvNeurN uint32

+ RecvNeurSt uint32

+ SendConSt uint32

+ SendNeurN uint32

+ SendNeurSt uint32

type PrjnParams

+ func (pj *PrjnParams) SynCaRecvSyn(ctx *Context, sy *Synapse, sn *Neuron, rnCaSyn, updtThr float32)

+ func (pj *PrjnParams) SynCaSendSyn(ctx *Context, sy *Synapse, rn *Neuron, snCaSyn, updtThr float32)

type PrjnTypes

+ const ForwardPrjn

type SynComParams

+ func (sc *SynComParams) FloatFromGBuf(ival int32) float32

+ func (sc *SynComParams) FloatToGBuf(val float32) int32

+ func (sc *SynComParams) FloatToIntFactor() float32

type Synapse

+ SynIdx uint32

Feb 9, 2023

Changes in this version

type NetworkBase

+ func (net *NetworkBase) GetLayersByTypes(types ...LayerTypes) []*Layer

Feb 8, 2023

Changes in this version

+ func GetRandomNumber(index uint32, counter slrand.Counter, funIdx RandFunIdx) float32

+ func LogInputLayer(lg *elog.Logs, net *Network)

type ActInitParams

+ func (ai *ActInitParams) GetGeBase() float32

+ func (ai *ActInitParams) GetGiBase() float32

+ type RandFunIdx uint32

+ const RandFunActPGe

+ const RandFunActPGi

+ const RandFunIdxN

Feb 4, 2023

Changes in this version

type AxonLayer

+ PoolGiFmSpikes func(ctx *Context)

type Layer

+ func (ly *Layer) BetweenLayerGi(ctx *Context)

+ func (ly *Layer) BetweenLayerGiMax(maxGi float32, net *Network, layIdx int32) float32

type LayerParams

+ LayInhib1Idx int32

+ LayInhib2Idx int32

+ LayInhib3Idx int32

+ LayInhib4Idx int32

Jan 30, 2023

Changes in this version

type AxonLayer

+ GatherSpikes func(ctx *Context, ni uint32, nrn *Neuron)

type AxonPrjn

+ RecvSpikes func(ctx *Context, recvIdx int)

type Context

+ ThetaCycles int32

type Layer

+ func (ly *Layer) GatherSpikes(ctx *Context, ni uint32, nrn *Neuron)

+ func (ly *Layer) PTMaintDefaults()

type LayerBase

+ func (ly *LayerBase) RecipToRecvPrjn(rpj emer.Prjn) (emer.Prjn, bool)

type LayerParams

+ func (ly *LayerParams) GatherSpikesInit(nrn *Neuron)

+ func (ly *LayerParams) GeToPool(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, subPool bool)

type Network

+ func (nt *Network) AddPTMaintLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddPTMaintLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddPTMaintThalForSuper(super, ct emer.Layer, suffix string, superToPT, ptSelf, ctToThal prjn.Pattern, ...) (pt, thal emer.Layer)

+ func (nt *Network) ConnectPTMaintSelf(ly emer.Layer, pat prjn.Pattern) emer.Prjn

type NetworkBase

+ CPURecvSpikes bool

+ MaxDelay uint32

+ PrjnGBuf []float32

+ PrjnGSyns []float32

+ Synapses []Synapse

+ func (nt *NetworkBase) BuildPrjnGBuf()

type Neuron

+ CtxtGeRaw float32

+ SubPoolN uint32

type Prjn

+ func (pj *Prjn) RecvSpikes(ctx *Context, recvIdx int)

type PrjnBase

+ GSyns []float32

+ RecvCon []StartN

+ SendCon []StartN

+ SendSynIdx []uint32

+ func (pj *PrjnBase) RecvSyns(ri int) []Synapse

+ func (pj *PrjnBase) SendSynIdxs(si int) []uint32

+ func (pj *PrjnBase) SetConStartN(con *[]StartN, avgmax *minmax.AvgMax32, tn *etensor.Int32) uint32

type PrjnGTypes

+ const ContextG

type PrjnIdxs

+ GBufSt uint32

+ GSynSt uint32

+ RecvConSt uint32

+ RecvLaySt uint32

+ SendLaySt uint32

+ SynapseSt uint32

+ func (pi *PrjnIdxs) RecvNIdxToLayIdx(ni uint32) uint32

+ func (pi *PrjnIdxs) SendNIdxToLayIdx(ni uint32) uint32

type PrjnParams

+ func (pj *PrjnParams) CycleSynCaSyn(ctx *Context, sy *Synapse, sn, rn *Neuron)

+ func (pj *PrjnParams) GatherSpikes(ctx *Context, ly *LayerParams, ni uint32, nrn *Neuron, gRaw float32, ...)

+ func (pj *PrjnParams) SynRecvLayIdx(sy *Synapse) uint32

+ func (pj *PrjnParams) SynSendLayIdx(sy *Synapse) uint32

+ type StartN struct

+ N uint32

+ Start uint32

type SynComParams

+ CPURecvSpikes slbool.Bool

+ DelLen uint32

+ MaxDelay uint32

+ func (sc *SynComParams) ReadIdx(rnIdx uint32, cycTot int32) uint32

+ func (sc *SynComParams) ReadOff(cycTot int32) uint32

+ func (sc *SynComParams) RingIdx(i uint32) uint32

+ func (sc *SynComParams) WriteIdx(rnIdx uint32, cycTot int32) uint32

+ func (sc *SynComParams) WriteIdxOff(rnIdx, wrOff uint32) uint32

+ func (sc *SynComParams) WriteOff(cycTot int32) uint32

type Synapse

+ DTr float32

+ PrjnIdx uint32

+ RecvIdx uint32

+ SendIdx uint32

Jan 26, 2023

Changes in this version

type NetThreads

+ func (nt *NetThreads) String() string

type Network

+ func (nt *Network) DecayStateByType(ctx *Context, decay, glong float32, types ...LayerTypes)

type NetworkBase

+ func (nt *NetworkBase) LayersByType(layType ...LayerTypes) []string

+ func (nt *NetworkBase) ThreadReport()

type NeuroModParams

+ AChLRateMod float32

+ DALRateMod float32

+ type PrjnGBuf struct

+ GRaw float32

type PrjnParams

+ func (pj *PrjnParams) RecvSynCaSyn(ctx *Context, sy *Synapse, sn *Neuron, rnCaSyn, updtThr float32)

+ func (pj *PrjnParams) SendSynCaSyn(ctx *Context, sy *Synapse, rn *Neuron, snCaSyn, updtThr float32)

Jan 24, 2023

Changes in this version

+ var KiT_DAModTypes = kit.Enums.AddEnum(DAModTypesN, kit.NotBitFlag, nil)

+ var KiT_GPLayerTypes = kit.Enums.AddEnum(GPLayerTypesN, kit.NotBitFlag, nil)

+ var KiT_LayerTypes = kit.Enums.AddEnum(LayerTypesN, kit.NotBitFlag, nil)

+ var KiT_PrjnGTypes = kit.Enums.AddEnum(PrjnGTypesN, kit.NotBitFlag, nil)

+ var KiT_PrjnTypes = kit.Enums.AddEnum(PrjnTypesN, kit.NotBitFlag, nil)

+ var NNeuronLayerVars = len(NeuronLayerVars)

+ var NeuronLayerVars = []string

+ func LogAddPulvCorSimItems(lg *elog.Logs, net *Network, times ...etime.Times)

+ func SetNeuronExtPosNeg(ni uint32, nrn *Neuron, val float32)

type ActParams

+ SKCa chans.SKCaParams

+ func (ac *ActParams) GSkCaFmCa(nrn *Neuron)

+ type AvgMaxPhases struct

+ Cycle minmax.AvgMax32

+ Minus minmax.AvgMax32

+ Plus minmax.AvgMax32

+ func (am *AvgMaxPhases) CycleToMinus()

+ func (am *AvgMaxPhases) CycleToPlus()

type AxonLayer

+ CtxtFmGe func(ctx *Context)

+ LayerType func() LayerTypes

+ PostBuild func()

+ PostSpike func(ctx *Context, ni uint32, nrn *Neuron)

+ SendCtxtGe func(ctx *Context)

+ SetBuildConfig func(param, val string)

type AxonPrjn

+ PrjnGatherSpikes func(ctx *Context)

+ PrjnType func() PrjnTypes

+ type BLAParams struct

+ NegLRate float32

+ func (bp *BLAParams) Defaults()

+ func (bp *BLAParams) Update()

+ type BurstParams struct

+ ThrAbs float32

+ ThrRel float32

+ func (bp *BurstParams) Defaults()

+ func (bp *BurstParams) ThrFmAvgMax(avg, mx float32) float32

+ func (bp *BurstParams) Update()

+ type CTParams struct

+ DecayDt float32

+ DecayTau float32

+ GeGain float32

+ func (cp *CTParams) Defaults()

+ func (cp *CTParams) Update()

type ClampParams

+ IsInput slbool.Bool

+ IsTarget slbool.Bool

+ type Context struct

+ Cycle int32

+ CycleTot int32

+ Mode etime.Modes

+ NeuroMod NeuroModVals

+ Phase int32

+ PhaseCycle int32

+ PlusPhase slbool.Bool

+ RandCtr slrand.Counter

+ RandsPerCyc uint32

+ Testing slbool.Bool

+ Time float32

+ TimePerCyc float32

+ func NewContext() *Context

+ func (tm *Context) CycleInc()

+ func (tm *Context) Defaults()

+ func (tm *Context) NewPhase(plusPhase bool)

+ func (tm *Context) NewState(mode etime.Modes)

+ func (tm *Context) Reset()

+ type DAModTypes int32

+ const D1AbsMod

+ const D1Mod

+ const D2Mod

+ const DAModTypesN

+ const NoDAMod

+ func (i *DAModTypes) FromString(s string) error

+ func (i DAModTypes) String() string

type DendParams

+ HasMod slbool.Bool

+ ModGain float32

+ type GPLayerTypes int32

+ const GPLayerTypesN

+ const GPeIn

+ const GPeOut

+ const GPeTA

+ const GPi

+ func (ev *GPLayerTypes) UnmarshalJSON(b []byte) error

+ func (ev GPLayerTypes) MarshalJSON() ([]byte, error)

+ func (i *GPLayerTypes) FromString(s string) error

+ func (i GPLayerTypes) String() string

+ type GPParams struct

+ GPType GPLayerTypes

+ func (gp *GPParams) Defaults()

+ func (gp *GPParams) Update()

type LRateParams

+ func (ls *LRateParams) UpdateEff()

+ type LaySpecialVals struct

+ V1 float32

+ V2 float32

+ V3 float32

+ V4 float32

type Layer

+ Params *LayerParams

+ Vals *LayerVals

+ func (ly *Layer) AnyGated() bool

+ func (ly *Layer) BLAPostBuild()

+ func (ly *Layer) CtxtFmGe(ctx *Context)

+ func (ly *Layer) DecayStateLayer(ctx *Context, decay, glong float32)

+ func (ly *Layer) GPDefaults()

+ func (ly *Layer) GPPostBuild()

+ func (ly *Layer) GPiDefaults()

+ func (ly *Layer) GatedFmSpkMax(thr float32) bool

+ func (ly *Layer) MatrixDefaults()

+ func (ly *Layer) MatrixGated() bool

+ func (ly *Layer) MatrixPostBuild()

+ func (ly *Layer) NeuronGatherSpikes(ctx *Context, ni uint32, nrn *Neuron)

+ func (ly *Layer) Object() interface{}

+ func (ly *Layer) PlusPhasePost(ctx *Context)

+ func (ly *Layer) PostBuild()

+ func (ly *Layer) PostSpike(ctx *Context, ni uint32, nrn *Neuron)

+ func (ly *Layer) PulvPostBuild()

+ func (ly *Layer) PulvinarDriver(ni uint32) (drvGe, nonDrvPct float32)

+ func (ly *Layer) RSalAChMaxLayAct(maxAct float32, net *Network, layIdx int32) float32

+ func (ly *Layer) RSalAChPostBuild()

+ func (ly *Layer) RWDaPostBuild()

+ func (ly *Layer) STNDefaults()

+ func (ly *Layer) SendCtxtGe(ctx *Context)

+ func (ly *Layer) TDDaPostBuild()

+ func (ly *Layer) TDIntegPostBuild()

+ func (ly *Layer) Update()

+ func (ly *Layer) VThalDefaults()

type LayerBase

+ BuildConfig map[string]string

+ Neurons []Neuron

+ Pools []Pool

+ func (ly *LayerBase) Build() error

+ func (ly *LayerBase) BuildConfigByName(nm string) (string, error)

+ func (ly *LayerBase) BuildConfigFindLayer(nm string, mustName bool) int32

+ func (ly *LayerBase) BuildPools(nu int) error

+ func (ly *LayerBase) BuildPrjns() error

+ func (ly *LayerBase) BuildSubPools()

+ func (ly *LayerBase) LayerType() LayerTypes

+ func (ly *LayerBase) Pool(idx int) *Pool

+ func (ly *LayerBase) PoolTry(idx int) (*Pool, error)

+ func (ly *LayerBase) RecvNameTry(receiver string) (emer.Prjn, error)

+ func (ly *LayerBase) RecvNameTypeTry(receiver, typ string) (emer.Prjn, error)

+ func (ly *LayerBase) SendNameTry(sender string) (emer.Prjn, error)

+ func (ly *LayerBase) SendNameTypeTry(sender, typ string) (emer.Prjn, error)

+ func (ly *LayerBase) SetBuildConfig(param, val string)

+ func (ly *LayerBase) VarRange(varNm string) (min, max float32, err error)

+ type LayerIdxs struct

+ NeurN uint32

+ NeurSt uint32

+ PoolSt uint32

+ RecvN uint32

+ RecvSt uint32

+ SendN uint32

+ SendSt uint32

+ type LayerParams struct

+ Act ActParams

+ BLA BLAParams

+ Burst BurstParams

+ CT CTParams

+ GP GPParams

+ Idxs LayerIdxs

+ Inhib InhibParams

+ LayType LayerTypes

+ Learn LearnNeurParams

+ Matrix MatrixParams

+ Pulv PulvParams

+ RSalACh RSalAChParams

+ RWDa RWDaParams

+ RWPred RWPredParams

+ TDDa TDDaParams

+ TDInteg TDIntegParams

+ func (ly *LayerParams) AllParams() string

+ func (ly *LayerParams) BLADefaults()

+ func (ly *LayerParams) CTDefaults()

+ func (ly *LayerParams) Defaults()

+ func (ly *LayerParams) GFmRawSyn(ctx *Context, ni uint32, nrn *Neuron, randctr *sltype.Uint2)

+ func (ly *LayerParams) GNeuroMod(ctx *Context, ni uint32, nrn *Neuron, vals *LayerVals)

+ func (ly *LayerParams) GeExtToPool(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, subPool bool)

+ func (ly *LayerParams) GiInteg(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, vals *LayerVals)

+ func (ly *LayerParams) LayPoolGiFmSpikes(ctx *Context, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) MinusPhase(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, vals *LayerVals)

+ func (ly *LayerParams) NeuronGatherSpikesInit(ctx *Context, ni uint32, nrn *Neuron)

+ func (ly *LayerParams) NewState(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, vals *LayerVals)

+ func (ly *LayerParams) PTMaintDefaults()

+ func (ly *LayerParams) PlusPhase(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) PostSpike(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, vals *LayerVals)

+ func (ly *LayerParams) PostSpikeSpecial(ctx *Context, ni uint32, nrn *Neuron, pl *Pool, lpl *Pool, vals *LayerVals)

+ func (ly *LayerParams) PulvDefaults()

+ func (ly *LayerParams) RWDefaults()

+ func (ly *LayerParams) RWPredDefaults()

+ func (ly *LayerParams) SpecialPostGs(ctx *Context, ni uint32, nrn *Neuron, randctr *sltype.Uint2, saveVal float32)

+ func (ly *LayerParams) SpecialPreGs(ctx *Context, ni uint32, nrn *Neuron, drvGe float32, nonDrvPct float32, ...) float32

+ func (ly *LayerParams) SpikeFmG(ctx *Context, ni uint32, nrn *Neuron)

+ func (ly *LayerParams) SubPoolGiFmSpikes(ctx *Context, pl *Pool, lpl *Pool, lyInhib bool, giMult float32)

+ func (ly *LayerParams) TDDefaults()

+ func (ly *LayerParams) TDPredDefaults()

+ func (ly *LayerParams) Update()

+ type LayerTypes int32

+ const BLALayer

+ const CTLayer

+ const CeMLayer

+ const CompareLayer

+ const GPLayer

+ const InputLayer

+ const LayerTypesN

+ const MatrixLayer

+ const PPTgLayer

+ const PTMaintLayer

+ const PulvinarLayer

+ const RSalienceAChLayer

+ const RWDaLayer

+ const RWPredLayer

+ const RewLayer

+ const STNLayer

+ const SuperLayer

+ const TDDaLayer

+ const TDIntegLayer

+ const TDPredLayer

+ const TRNLayer

+ const TargetLayer

+ const VThalLayer

+ func (ev *LayerTypes) UnmarshalJSON(b []byte) error

+ func (ev LayerTypes) MarshalJSON() ([]byte, error)

+ func (i *LayerTypes) FromString(s string) error

+ func (i LayerTypes) String() string

+ type LayerVals struct

+ ActAvg ActAvgVals

+ CorSim CorSimStats

+ NeuroMod NeuroModVals

+ Special LaySpecialVals

type LearnNeurParams

+ NeuroMod NeuroModParams

+ type MatrixParams struct

+ GateThr float32

+ NoGoGeLrn float32

+ OtherMatrixIdx int32

+ ThalLay1Idx int32

+ ThalLay2Idx int32

+ ThalLay3Idx int32

+ ThalLay4Idx int32

+ ThalLay5Idx int32

+ func (mp *MatrixParams) Defaults()

+ func (mp *MatrixParams) Update()

+ type MatrixPrjnParams struct

+ AChDecay float32

+ CurTrlDA slbool.Bool

+ NoGateLRate float32

+ UseHasRew slbool.Bool

+ func (tp *MatrixPrjnParams) Defaults()

+ func (tp *MatrixPrjnParams) TraceDecay(ctx *Context, ach float32) float32

+ func (tp *MatrixPrjnParams) Update()

type Network

+ func (nt *Network) AddAmygdala(prefix string, neg bool, nUs, unY, unX int, space float32) (blaPosAcq, blaPosExt, blaNegAcq, blaNegExt, cemPos, cemNeg, pptg AxonLayer)

+ func (nt *Network) AddBG(prefix string, nPoolsY, nPoolsX, nNeurY, nNeurX, gpNeurY, gpNeurX int, ...) (mtxGo, mtxNo, gpeOut, gpeIn, gpeTA, stnp, stns, gpi AxonLayer)

+ func (nt *Network) AddBG4D(prefix string, nPoolsY, nPoolsX, nNeurY, nNeurX, gpNeurY, gpNeurX int, ...) (mtxGo, mtxNo, gpeOut, gpeIn, gpeTA, stnp, stns, gpi AxonLayer)

+ func (nt *Network) AddBLALayers(prefix string, pos bool, nUs, unY, unX int, rel relpos.Relations, ...) (acq, ext AxonLayer)

+ func (nt *Network) AddCINLayer(name, mtxGo, mtxNo string, space float32) *Layer

+ func (nt *Network) AddCTLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddCTLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddClampDaLayer(name string) *Layer

+ func (nt *Network) AddGPeLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddGPeLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddGPiLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddGPiLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddInputPulv2D(name string, nNeurY, nNeurX int, space float32) (emer.Layer, *Layer)

+ func (nt *Network) AddInputPulv4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int, space float32) (emer.Layer, *Layer)

+ func (nt *Network) AddMatrixLayer(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int, da DAModTypes) *Layer

+ func (nt *Network) AddPPTgLayer(prefix string, nUs, unY, unX int) AxonLayer

+ func (nt *Network) AddPTLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddPTLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddPTThalForSuper(super, ct emer.Layer, suffix string, superToPT, ptSelf, ctToThal prjn.Pattern, ...) (pt, thal emer.Layer)

+ func (nt *Network) AddPulvForSuper(super emer.Layer, space float32) emer.Layer

+ func (nt *Network) AddPulvLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddPulvLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddRSalienceAChLayer(name string) *Layer

+ func (nt *Network) AddRWLayers(prefix string, rel relpos.Relations, space float32) (rew, rp, da AxonLayer)

+ func (nt *Network) AddRewLayer(name string) *Layer

+ func (nt *Network) AddSTNLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddSTNLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddSuperCT2D(name string, shapeY, shapeX int, space float32, pat prjn.Pattern) (super, ct emer.Layer)

+ func (nt *Network) AddSuperCT4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int, space float32, ...) (super, ct emer.Layer)

+ func (nt *Network) AddSuperLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddSuperLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddTDLayers(prefix string, rel relpos.Relations, space float32) (rew, rp, ri, td AxonLayer)

+ func (nt *Network) AddThalLayer2D(name string, nNeurY, nNeurX int) *Layer

+ func (nt *Network) AddThalLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int) *Layer

+ func (nt *Network) CTCtxt(ctx *Context)

+ func (nt *Network) ConnectCTSelf(ly emer.Layer, pat prjn.Pattern) (ctxt, maint emer.Prjn)

+ func (nt *Network) ConnectCtxtToCT(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectPTSelf(ly emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectSuperToCT(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectToBLA(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectToMatrix(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *Network) ConnectToPulv(super, ct, pulv emer.Layer, toPulvPat, fmPulvPat prjn.Pattern) (toPulv, toSuper, toCT emer.Prjn)

+ func (nt *Network) ConnectToRWPrjn(send, recv emer.Layer, pat prjn.Pattern) emer.Prjn

type NetworkBase

+ LayParams []LayerParams

+ LayVals []LayerVals

+ PrjnParams []PrjnParams

+ PrjnVals []PrjnVals

+ type NeurSynIdx struct

+ NeurIdx uint32

+ PrjnIdx uint32

+ SynN uint32

+ SynSt uint32

+ type NeuroModParams struct

+ AChDisInhib float32

+ AChLrateMod slbool.Bool

+ AChLratePct float32

+ BurstGain float32

+ DALrateMod slbool.Bool

+ DALratePct float32

+ DAMod DAModTypes

+ DAModGain float32

+ DipGain float32

+ func (nm *NeuroModParams) Defaults()

+ func (nm *NeuroModParams) GGain(da float32) float32

+ func (nm *NeuroModParams) GiFmACh(ach float32) float32

+ func (nm *NeuroModParams) LRMod(da, ach float32) float32

+ func (nm *NeuroModParams) LRModFact(on bool, pct, val float32) float32

+ func (nm *NeuroModParams) Update()

+ type NeuroModVals struct

+ ACh float32

+ AChRaw float32

+ DA float32

+ HasRew slbool.Bool

+ NE float32

+ PrevPred float32

+ Rew float32

+ RewPred float32

+ Ser float32

+ func (nm *NeuroModVals) NewState()

+ func (nm *NeuroModVals) Reset()

+ func (nm *NeuroModVals) SetRew(rew float32, hasRew bool)

type Neuron

+ Burst float32

+ BurstPrv float32

+ CtxtGe float32

+ GModRaw float32

+ GModSyn float32

+ GeSynMax float32

+ GeSynPrv float32

+ Gsk float32

+ NeurIdx uint32

+ SKCaM float32

+ SKCai float32

+ SubPoolG uint32

type Pool

+ AvgMax PoolAvgMax

+ EdIdxG uint32

+ Gated slbool.Bool

+ IsLayPool slbool.Bool

+ LayIdx uint32

+ LayPoolIdx uint32

+ PoolIdx uint32

+ StIdxG uint32

+ type PoolAvgMax struct

+ Act AvgMaxPhases

+ CaSpkD AvgMaxPhases

+ CaSpkP AvgMaxPhases

+ Ge AvgMaxPhases

+ Gi AvgMaxPhases

+ SpkMax AvgMaxPhases

+ func (am *PoolAvgMax) CalcAvg()

+ func (am *PoolAvgMax) CycleToMinus()

+ func (am *PoolAvgMax) CycleToPlus()

+ func (am *PoolAvgMax) Init()

+ func (am *PoolAvgMax) UpdateVals(nrn *Neuron, ni int32)

type Prjn

+ Params *PrjnParams

+ Vals *PrjnVals

+ func (pj *Prjn) Class() string

+ func (pj *Prjn) Object() interface{}

+ func (pj *Prjn) PrjnGatherSpikes(ctx *Context)

+ func (pj *Prjn) PrjnType() PrjnTypes

+ func (pj *Prjn) RecvCtxtGeInc()

+ func (pj *Prjn) SendCtxtGe(si int, burst float32)

+ func (pj *Prjn) Update()

type PrjnBase

+ GBuf []float32

+ GVals []PrjnGVals

+ PIBuf []float32

+ PIdxs []uint32

+ Syns []Synapse

+ func (pj *PrjnBase) Build() error

+ func (pj *PrjnBase) SetClass(cls string) emer.Prjn

+ func (pj *PrjnBase) SetPattern(pat prjn.Pattern) emer.Prjn

+ func (pj *PrjnBase) SetType(typ emer.PrjnType) emer.Prjn

+ func (pj *PrjnBase) Syn1DNum() int

+ func (pj *PrjnBase) SynIdx(sidx, ridx int) int

+ func (pj *PrjnBase) SynVal(varNm string, sidx, ridx int) float32

+ func (pj *PrjnBase) SynVal1D(varIdx int, synIdx int) float32

+ func (pj *PrjnBase) SynVals(vals *[]float32, varNm string) error

+ func (pj *PrjnBase) SynVarIdx(varNm string) (int, error)

+ func (pj *PrjnBase) SynVarNames() []string

+ func (pj *PrjnBase) SynVarNum() int

+ func (pj *PrjnBase) SynVarProps() map[string]string

+ type PrjnGTypes int32

+ const ExcitatoryG

+ const InhibitoryG

+ const ModulatoryG

+ const PrjnGTypesN

+ func (ev *PrjnGTypes) UnmarshalJSON(b []byte) error

+ func (ev PrjnGTypes) MarshalJSON() ([]byte, error)

+ func (i *PrjnGTypes) FromString(s string) error

+ func (i PrjnGTypes) String() string

+ type PrjnIdxs struct

+ PrjnIdx uint32

+ RecvLay uint32

+ RecvLayN uint32

+ RecvPrjnGVSt uint32

+ RecvSynSt uint32

+ SendLay uint32

+ SendLayN uint32

+ SendSynSt uint32

+ type PrjnParams struct

+ Com SynComParams

+ GScale GScaleVals

+ Idxs PrjnIdxs

+ Learn LearnSynParams

+ Matrix MatrixPrjnParams

+ PrjnScale PrjnScaleParams

+ PrjnType PrjnTypes

+ RLPred RLPredPrjnParams

+ SWt SWtParams

+ func (pj *PrjnParams) AllParams() string

+ func (pj *PrjnParams) BLAPrjnDefaults()

+ func (pj *PrjnParams) DWtSyn(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool, ...)

+ func (pj *PrjnParams) DWtSynCortex(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool, ...)

+ func (pj *PrjnParams) DWtSynMatrix(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool)

+ func (pj *PrjnParams) DWtSynRWPred(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool)

+ func (pj *PrjnParams) DWtSynTDPred(ctx *Context, sy *Synapse, sn, rn *Neuron, layPool, subPool *Pool)

+ func (pj *PrjnParams) Defaults()

+ func (pj *PrjnParams) IsExcitatory() bool

+ func (pj *PrjnParams) IsInhib() bool

+ func (pj *PrjnParams) NeuronGatherSpikesPrjn(ctx *Context, gv PrjnGVals, ni uint32, nrn *Neuron)

+ func (pj *PrjnParams) RLPredPrjnDefaults()

+ func (pj *PrjnParams) Update()

+ func (pj *PrjnParams) WtFmDWtSyn(ctx *Context, sy *Synapse)

+ func (pj *PrjnParams) WtFmDWtSynCortex(ctx *Context, sy *Synapse)

+ func (pj *PrjnParams) WtFmDWtSynNoLimits(ctx *Context, sy *Synapse)

+ type PrjnTypes int32

+ const BLAPrjn

+ const BackPrjn

+ const CTCtxtPrjn

+ const ForwardPrj

+ const InhibPrjn

+ const LateralPrjn

+ const MatrixPrjn

+ const PrjnTypesN

+ const RWPrjn

+ const TDPredPrjn

+ func (ev *PrjnTypes) UnmarshalJSON(b []byte) error

+ func (ev PrjnTypes) MarshalJSON() ([]byte, error)

+ func (i *PrjnTypes) FromString(s string) error

+ func (i PrjnTypes) String() string

+ type PrjnVals struct

+ Gidx ringidx.FIx

+ type PulvParams struct

+ DriveLayIdx int32

+ DriveScale float32

+ FullDriveAct float32

+ func (tp *PulvParams) Defaults()

+ func (tp *PulvParams) DriveGe(act float32) float32

+ func (tp *PulvParams) NonDrivePct(drvMax float32) float32

+ func (tp *PulvParams) Update()

+ type RLPredPrjnParams struct

+ DaTol float32

+ OppSignLRate float32

+ func (pj *RLPredPrjnParams) Defaults()

+ func (pj *RLPredPrjnParams) Update()

+ type RSalAChParams struct

+ Rew slbool.Bool

+ RewPred slbool.Bool

+ RewThr float32

+ SrcLay1Idx int32

+ SrcLay2Idx int32

+ SrcLay3Idx int32

+ SrcLay4Idx int32

+ SrcLay5Idx int32

+ func (rp *RSalAChParams) Defaults()

+ func (rp *RSalAChParams) Thr(val float32) float32

+ func (rp *RSalAChParams) Update()

+ type RWDaParams struct

+ RWPredLayIdx int32

+ TonicGe float32

+ func (rp *RWDaParams) Defaults()

+ func (rp *RWDaParams) GeFmDA(da float32) float32

+ func (rp *RWDaParams) Update()

+ type RWPredParams struct

+ PredRange minmax.F32

+ func (rp *RWPredParams) Defaults()

+ func (rp *RWPredParams) Update()

type SynComParams

+ GType PrjnGTypes

+ type SynIdx struct

+ SendNeurIdx uint32

+ SynIdx uint32

type Synapse

+ RecvNeurIdx uint32

+ type TDDaParams struct

+ TDIntegLayIdx int32

+ TonicGe float32

+ func (tp *TDDaParams) Defaults()

+ func (tp *TDDaParams) GeFmDA(da float32) float32

+ func (tp *TDDaParams) Update()

+ type TDIntegParams struct

+ Discount float32

+ PredGain float32

+ TDPredLayIdx int32

+ func (tp *TDIntegParams) Defaults()

+ func (tp *TDIntegParams) Update()

Jan 9, 2023

Changes in this version

type NetworkBase

+ func (nt *NetworkBase) LayerMapParallel(fun func(ly AxonLayer), funame string, nThreads int)

+ func (nt *NetworkBase) LayerMapSeq(fun func(ly AxonLayer), funame string)

+ func (nt *NetworkBase) NeuronMapParallel(fun func(ly AxonLayer, ni int, nrn *Neuron), funame string, nThreads int)

+ func (nt *NetworkBase) NeuronMapSequential(fun func(ly AxonLayer, ni int, nrn *Neuron), funame string)

+ func (nt *NetworkBase) PrjnMapParallel(fun func(pj AxonPrjn), funame string, nThreads int)

+ func (nt *NetworkBase) PrjnMapSeq(fun func(pj AxonPrjn), funame string)

Dec 21, 2022

Changes in this version

type ActAvgParams

+ Nominal float32

+ Offset float32

Dec 14, 2022

Changes in this version

type TrgAvgActParams

+ DownOnly bool

+ TrgMult bool

Dec 10, 2022

Changes in this version

type AxonLayer

+ RecvPrjns func() *AxonPrjns

+ SendPrjns func() *AxonPrjns

+ type AxonPrjns []AxonPrjn

+ func (pl *AxonPrjns) Add(p AxonPrjn)

type Layer

+ func (ly *Layer) RecvNameTry(receiver string) (emer.Prjn, error)

+ func (ly *Layer) RecvNameTypeTry(receiver, typ string) (emer.Prjn, error)

+ func (ly *Layer) SendNameTry(sender string) (emer.Prjn, error)

+ func (ly *Layer) SendNameTypeTry(sender, typ string) (emer.Prjn, error)

Dec 8, 2022

Changes in this version

+ type LRateMod struct

+ Base float32

+ On bool

+ Range minmax.F32

+ func (lr *LRateMod) Defaults()

+ func (lr *LRateMod) LRateMod(net *Network, fact float32) float32

+ func (lr *LRateMod) Mod(fact float32) float32

+ func (lr *LRateMod) Update()

+ type LRateParams struct

+ Base float32

+ Eff float32

+ Mod float32

+ Sched float32

+ func (ls *LRateParams) Defaults()

+ func (ls *LRateParams) Init()

+ func (ls *LRateParams) Update()

type Layer

+ func (ly *Layer) LRateMod(mod float32)

+ func (ly *Layer) LRateSched(sched float32)

type LearnNeurParams

+ RLRate RLRateParams

type LearnSynParams

+ LRate LRateParams

type Network

+ func (nt *Network) LRateMod(mod float32)

+ func (nt *Network) LRateSched(sched float32)

type Neuron

+ RLRate float32

type Prjn

+ func (pj *Prjn) LRateMod(mod float32)

+ func (pj *Prjn) LRateSched(sched float32)

+ type RLRateParams struct

+ Diff bool

+ DiffThr float32

+ Min float32

+ On bool

+ SigmoidMin float32

+ SpkThr float32

+ func (rl *RLRateParams) Defaults()

+ func (rl *RLRateParams) RLRateDiff(scap, scad float32) float32

+ func (rl *RLRateParams) RLRateSigDeriv(act float32, laymax float32) float32

+ func (rl *RLRateParams) Update()

type SWtAdaptParams

+ LRate float32

type TrgAvgActParams

+ ErrLRate float32

Dec 6, 2022

Changes in this version

type ActParams

+ func (ac *ActParams) SpikeFmVm(nrn *Neuron)

type AxonLayer

+ SendSpikes func(ni int, nrn *Neuron, ctime *Time)

type AxonPrjn

+ SendSpikes func(si int)

type CaLrnParams

+ NormInv float32

type Layer

+ func (ly *Layer) SendSpikes(ni int, nrn *Neuron, ctime *Time)

type Prjn

+ func (pj *Prjn) SendSpikes(sendIdx int)

type PrjnBase

+ RecvConIdx []int32

+ RecvConIdxStart []int32

+ RecvConN []int32

+ RecvConNAvgMax minmax.AvgMax32

+ RecvSynIdx []int32

+ SendConIdx []int32

+ SendConIdxStart []int32

+ SendConN []int32

+ SendConNAvgMax minmax.AvgMax32

Nov 29, 2022

Changes in this version

type Layer

+ func (ly *Layer) IsInputOrTarget() bool

+ func (ly *Layer) SetSubMean(trgAvg, prjn float32)

type Network

+ func (nt *Network) SetSubMean(trgAvg, prjn float32)

Nov 28, 2022

Changes in this version

type DendParams

+ SSGi float32

+ SSGi0 float32

type Neuron

+ GeTrgAvg float32

+ SSGi float32

+ SSGiDend float32

Nov 25, 2022

Changes in this version

type TrgAvgActParams

+ GeBase float32

+ func (ta *TrgAvgActParams) GeBaseFmTrg(trg float32) float32

Nov 22, 2022

Changes in this version

+ var KiT_SigDerivVars = kit.Enums.AddEnum(SigDerivVarsN, kit.NotBitFlag, nil)

type ActAvgVals

+ CaSpkD minmax.AvgMax32

type RLrateParams

+ SigVar SigDerivVars

+ type SigDerivVars int

+ const SigDerivD

+ const SigDerivM

+ const SigDerivP

+ const SigDerivVarsN

+ func (ev *SigDerivVars) UnmarshalJSON(b []byte) error

+ func (ev SigDerivVars) MarshalJSON() ([]byte, error)

+ func (i *SigDerivVars) FromString(s string) error

+ func (i SigDerivVars) String() string

Nov 21, 2022

Changes in this version

type Neuron

+ CaSpkPM float32

Nov 19, 2022

Changes in this version

type ActAvgParams

+ Target float32

type Neuron

+ Target float32

+ type NeuronFlags int32

+ const NeuronFlagsNum

+ const NeuronHasCmpr

+ const NeuronHasExt

+ const NeuronHasTarg

+ const NeuronOff

+ func (ev *NeuronFlags) UnmarshalJSON(b []byte) error

+ func (ev NeuronFlags) MarshalJSON() ([]byte, error)

+ func (i *NeuronFlags) FromString(s string) error

+ func (i NeuronFlags) String() string

Nov 10, 2022

Changes in this version

+ var GreedyChunks = true

+ type NetThread struct

+ ChunksPer int

+ NThreads int

+ Work WorkMgr

+ func (th *NetThread) Alloc(tot int)

+ func (th *NetThread) Run(fun func(st, ed int))

+ func (th *NetThread) Set(nthr, chk int)

+ type NetThreads struct

+ Learn NetThread

+ Neurons NetThread

+ SendSpike NetThread

+ SynCa NetThread

+ func (nt *NetThreads) Alloc(nNeurons, nPrjns int)

+ func (nt *NetThreads) Set(chk, neurons, sendSpike, synCa, learn int)

+ func (nt *NetThreads) SetDefaults(nNeurons, nPrjns int)

type NetworkBase

+ Threads NetThreads

+ func (nt *NetworkBase) LearnFun(fun func(pj AxonPrjn), funame string, thread, wait bool)

+ func (nt *NetworkBase) SendSpikeFun(fun func(ly AxonLayer, ni int, nrn *Neuron), funame string, thread, wait bool)

+ func (nt *NetworkBase) SynCaFun(fun func(pj AxonPrjn), funame string, thread, wait bool)

+ func (nt *NetworkBase) ThreadsAlloc()

+ type StartEnd struct

+ End int

+ Start int

+ type WorkMgr struct

+ Chunks []StartEnd

+ Cur atomctr.Ctr

+ Wait sync.WaitGroup

+ func (wm *WorkMgr) Alloc(tot, nThr, chunksPer int)

+ func (wm *WorkMgr) Run(nthr int, fun func(st, ed int))

Nov 9, 2022

Changes in this version

+ const NoThread

+ const NoWait

+ const Thread

+ const Wait

type ActParams

+ func (ac *ActParams) GkFmVm(nrn *Neuron)

+ func (ac *ActParams) SpikeFmG(nrn *Neuron)

type AxonLayer

+ CycleNeuron func(ni int, nrn *Neuron, ctime *Time)

+ DWtLayer func(ctime *Time)

+ NeurStartIdx func() int

+ SpikeFmG func(ni int, nrn *Neuron, ctime *Time)

+ WtFmDWtLayer func(ctime *Time)

type AxonPrjn

+ GFmSpikes func(ctime *Time)

type InhibMiscParams

+ PoolMaxFS bool

type Layer

+ func (ly *Layer) AvgDifFmTrgAvg()

+ func (ly *Layer) AvgMaxVarByPool(varNm string, poolIdx int) minmax.AvgMax32

+ func (ly *Layer) CycleNeuron(ni int, nrn *Neuron, ctime *Time)

+ func (ly *Layer) DTrgSubMean()

+ func (ly *Layer) DWtLayer(ctime *Time)

+ func (ly *Layer) GFmRawSyn(ni int, nrn *Neuron, ctime *Time)

+ func (ly *Layer) GFmSpikeRaw(ni int, nrn *Neuron, ctime *Time)

+ func (ly *Layer) GiInteg(ni int, nrn *Neuron, ctime *Time)

+ func (ly *Layer) SpikeFmG(ni int, nrn *Neuron, ctime *Time)

+ func (ly *Layer) WtFmDWtLayer(ctime *Time)

type LayerBase

+ NeurStIdx int

+ func (ls *LayerBase) NeurStartIdx() int

type NetworkBase

+ Neurons []Neuron

+ Prjns []AxonPrjn

+ RecFunTimes bool

+ func (nt *NetworkBase) LayerFun(fun func(ly AxonLayer), funame string, thread, wait bool)

+ func (nt *NetworkBase) NeuronFun(fun func(ly AxonLayer, ni int, nrn *Neuron), funame string, thread, wait bool)

+ func (nt *NetworkBase) PrjnFun(fun func(pj AxonPrjn), funame string, thread, wait bool)

type Neuron

+ LayIdx int32

type Prjn

+ func (pj *Prjn) GFmSpikes(ctime *Time)

Nov 7, 2022

Changes in this version

type ActParams

+ func (ac *ActParams) GeFmSyn(nrn *Neuron, geSyn, geExt float32)

+ func (ac *ActParams) GiFmSyn(nrn *Neuron, giSyn float32) float32

type AxonLayer

+ GFmSpikesPrjn func(ltime *Time)

+ GInteg func(ltime *Time)

+ GiFmSpikes func(ltime *Time)

type AxonPrjn

+ GFmSpike func(ltime *Time)

type DtParams

+ func (dp *DtParams) GeSynFmRawSteady(geRaw float32) float32

+ func (dp *DtParams) GiSynFmRawSteady(giRaw float32) float32

type InhibMiscParams

+ Old bool

type InhibParams

+ OldLayer fffb.Params

+ OldPool fffb.Params

type Layer

+ func (ly *Layer) GFmRawSynNeuron(ltime *Time, ni int, nrn *Neuron)

+ func (ly *Layer) GFmSpikeNeuron(ltime *Time, ni int, nrn *Neuron)

+ func (ly *Layer) GFmSpikesPrjn(ltime *Time)

+ func (ly *Layer) GInteg(ltime *Time)

+ func (ly *Layer) GiFmSpikes(ltime *Time)

+ func (ly *Layer) InitPrjnGBuffs()

+ func (ly *Layer) PoolGiFmSpikes(ltime *Time)

type Neuron

+ GeExt float32

+ SpkMaxCa float32

type Pool

+ OldInhib fffb.Inhib

+ func (pl *Pool) NNeurons() int

type Prjn

+ GVals []PrjnGVals

+ PIBuf []float32

+ PIdxs []int32

+ func (pj *Prjn) GFmSpike(ltime *Time)

+ type PrjnGVals struct

+ GRaw float32

+ GSyn float32

+ func (pv *PrjnGVals) Init()

Oct 27, 2022

Changes in this version

type AxonLayer

+ SpkSt1 func(ltime *Time)

+ SpkSt2 func(ltime *Time)

type AxonPrjn

+ InitGBuffs func()

type DtParams

+ MaxCycStart int

type Layer

+ func (ly *Layer) InitRecvGBuffs()

+ func (ly *Layer) MaxSpkMax() float32

+ func (ly *Layer) SpkMaxAvgByPool(pli int) float32

+ func (ly *Layer) SpkMaxMaxByPool(pli int) float32

+ func (ly *Layer) SpkSt1(ltime *Time)

+ func (ly *Layer) SpkSt2(ltime *Time)

type Network

+ func (nt *Network) DecayStateByClass(decay, glong float32, class ...string)

+ func (nt *Network) SpkSt1(ltime *Time)

+ func (nt *Network) SpkSt2(ltime *Time)

type Neuron

+ SpkMax float32

+ SpkPrv float32

+ SpkSt1 float32

+ SpkSt2 float32

type Prjn

+ func (pj *Prjn) BuildGBuffs()

+ func (pj *Prjn) DWtTraceNeurSpkTheta(ltime *Time)

+ func (pj *Prjn) InitGBuffs()

type RLrateParams

+ DiffThr float32

+ SpkThr float32

+ func (rl *RLrateParams) RLrateSigDeriv(act float32, laymax float32) float32

type TraceParams

+ NeuronCa bool

+ TrgNeuronCa bool

Oct 14, 2022

Changes in this version

+ func LogAddExtraDiagnosticItems(lg *elog.Logs, net *Network, times ...etime.Times)

Oct 12, 2022

Changes in this version

type Layer

+ func (ly *Layer) AvgMaxCaSpkP(ltime *Time)

Oct 10, 2022

Changes in this version

type TraceParams

+ NoExp2 bool

Oct 2, 2022

Changes in this version

+ func LogAddCaLrnDiagnosticItems(lg *elog.Logs, net *Network, times ...etime.Times)

type ActParams

+ Mahp chans.MahpParams

+ Sahp chans.SahpParams

type DecayParams

+ AHP float32

type Layer

+ func (ly *Layer) LocalistErr2D() (err bool, minusIdx, plusIdx int)

+ func (ly *Layer) LocalistErr4D() (err bool, minusIdx, plusIdx int)

type Neuron

+ SahpCa float32

+ SahpN float32

Sep 29, 2022

Changes in this version

type ActParams

+ MAHP chans.MAHPParams

type Neuron

+ MahpN float32

Sep 12, 2022

Changes in this version

type ActAvgVals

+ CaSpkP minmax.AvgMax32

+ CaSpkPM minmax.AvgMax32

type ActInitParams

+ GeVar float32

+ GiVar float32

+ func (ai *ActInitParams) GeBase() float32

+ func (ai *ActInitParams) GiBase() float32

+ type CaLrnParams struct

+ Dt kinase.CaDtParams

+ Norm float32

+ SpkVGCC bool

+ SpkVgccCa float32

+ VgccDt float32

+ VgccTau float32

+ func (np *CaLrnParams) CaLrn(nrn *Neuron)

+ func (np *CaLrnParams) Defaults()

+ func (np *CaLrnParams) Update()

+ func (np *CaLrnParams) VgccCa(nrn *Neuron)

+ type CaSpkParams struct

+ Dt kinase.CaDtParams

+ SpikeG float32

+ SynDt float32

+ SynSpkG float32

+ SynTau float32

+ func (np *CaSpkParams) CaFmSpike(nrn *Neuron)

+ func (np *CaSpkParams) Defaults()

+ func (np *CaSpkParams) Update()

type Layer

+ func (ly *Layer) DecayCaLrnSpk(decay float32)

+ func (ly *Layer) SpikeAvgByPool(pli int) float32

+ func (ly *Layer) SpikedAvgByPool(pli int) float32

type LearnNeurParams

+ CaLrn CaLrnParams

+ CaSpk CaSpkParams

+ func (ln *LearnNeurParams) DecayCaLrnSpk(nrn *Neuron, decay float32)

type LearnSynParams

+ Trace TraceParams

+ func (ls *LearnSynParams) DeltaDWt(plus, minus float32) float32

type Neuron

+ ActDiff float32

+ CaDiff float32

+ CaSpkD float32

+ CaSpkM float32

+ CaSpkP float32

+ GeBase float32

+ GiBase float32

+ GnmdaLrn float32

+ NmdaCa float32

+ Spiked float32

+ VgccCaInt float32

type Prjn

+ func (pj *Prjn) DWtCHL(ltime *Time)

+ func (pj *Prjn) DWtTraceSynSpkTheta(ltime *Time)

type RLrateParams

+ ActDiffThr float32

+ Diff bool

+ SigmoidMin float32

+ func (rl *RLrateParams) RLrateDiff(scap, scad float32) float32

+ func (rl *RLrateParams) RLrateMid(nrn *Neuron, laymax float32) float32

type SWtAdaptParams

+ SubMean float32

type Synapse

+ Tr float32

+ type TraceParams struct

+ Dt float32

+ SubMean float32

+ Tau float32

+ func (tp *TraceParams) Defaults()

+ func (tp *TraceParams) TrFmCa(tr float32, ca float32) float32

+ func (tp *TraceParams) Update()

type TrgAvgActParams

+ SubMean float32

Aug 18, 2022

Changes in this version

+ type PrjnBase struct

+ AxonPrj AxonPrjn

+ Cls string

+ Notes string

+ Off bool

+ Pat prjn.Pattern

+ RConIdx []int32

+ RConIdxSt []int32

+ RConN []int32

+ RConNAvgMax minmax.AvgMax32

+ RSynIdx []int32

+ Recv emer.Layer

+ SConIdx []int32

+ SConIdxSt []int32

+ SConN []int32

+ SConNAvgMax minmax.AvgMax32

+ Send emer.Layer

+ Typ emer.PrjnType

+ func (ps *PrjnBase) ApplyParams(pars *params.Sheet, setMsg bool) (bool, error)

+ func (ps *PrjnBase) BuildBase() error

+ func (ps *PrjnBase) Class() string

+ func (ps *PrjnBase) Connect(slay, rlay emer.Layer, pat prjn.Pattern, typ emer.PrjnType)

+ func (ps *PrjnBase) Init(prjn emer.Prjn)

+ func (ps *PrjnBase) IsOff() bool

+ func (ps *PrjnBase) Label() string

+ func (ps *PrjnBase) Name() string

+ func (ps *PrjnBase) NonDefaultParams() string

+ func (ps *PrjnBase) Pattern() prjn.Pattern

+ func (ps *PrjnBase) PrjnTypeName() string

+ func (ps *PrjnBase) RecvLay() emer.Layer

+ func (ps *PrjnBase) SendLay() emer.Layer

+ func (ps *PrjnBase) SetNIdxSt(n *[]int32, avgmax *minmax.AvgMax32, idxst *[]int32, tn *etensor.Int32) int32

+ func (ps *PrjnBase) SetOff(off bool)

+ func (ps *PrjnBase) String() string

+ func (ps *PrjnBase) Type() emer.PrjnType

+ func (ps *PrjnBase) TypeName() string

+ func (ps *PrjnBase) Validate(logmsg bool) error

Jun 13, 2022

Changes in this version

type LayerBase

+ RepShp etensor.Shape

+ func (ls *LayerBase) RepShape() *etensor.Shape

+ func (ls *LayerBase) SetRepIdxsShape(idxs, shape []int)

Jun 11, 2022

Changes in this version

type AxonLayer

+ Cycle func(ltime *Time)

type Layer

+ func (ly *Layer) Cycle(ltime *Time)

+ type LayerBase struct

+ AxonLay AxonLayer

+ Cls string

+ Idx int

+ Network emer.Network

+ Nm string

+ Off bool

+ Ps mat32.Vec3

+ RcvPrjns emer.Prjns

+ Rel relpos.Rel

+ RepIxs []int

+ Shp etensor.Shape

+ SndPrjns emer.Prjns

+ Thr int

+ Typ emer.LayerType

+ func (ls *LayerBase) ApplyParams(pars *params.Sheet, setMsg bool) (bool, error)

+ func (ls *LayerBase) Class() string

+ func (ls *LayerBase) Config(shape []int, typ emer.LayerType)

+ func (ls *LayerBase) Idx4DFrom2D(x, y int) ([]int, bool)

+ func (ls *LayerBase) Index() int

+ func (ls *LayerBase) InitName(lay emer.Layer, name string, net emer.Network)

+ func (ls *LayerBase) Is2D() bool

+ func (ls *LayerBase) Is4D() bool

+ func (ls *LayerBase) IsOff() bool

+ func (ls *LayerBase) Label() string

+ func (ls *LayerBase) NPools() int

+ func (ls *LayerBase) NRecvPrjns() int

+ func (ls *LayerBase) NSendPrjns() int

+ func (ls *LayerBase) Name() string

+ func (ls *LayerBase) NonDefaultParams() string

+ func (ls *LayerBase) Pos() mat32.Vec3

+ func (ls *LayerBase) RecipToSendPrjn(spj emer.Prjn) (emer.Prjn, bool)

+ func (ls *LayerBase) RecvPrjn(idx int) emer.Prjn

+ func (ls *LayerBase) RecvPrjns() *emer.Prjns

+ func (ls *LayerBase) RelPos() relpos.Rel

+ func (ls *LayerBase) RepIdxs() []int

+ func (ls *LayerBase) SendPrjn(idx int) emer.Prjn

+ func (ls *LayerBase) SendPrjns() *emer.Prjns

+ func (ls *LayerBase) SetClass(cls string)

+ func (ls *LayerBase) SetIndex(idx int)

+ func (ls *LayerBase) SetName(nm string)

+ func (ls *LayerBase) SetOff(off bool)

+ func (ls *LayerBase) SetPos(pos mat32.Vec3)

+ func (ls *LayerBase) SetRelPos(rel relpos.Rel)

+ func (ls *LayerBase) SetRepIdxs(idxs []int)

+ func (ls *LayerBase) SetShape(shape []int)

+ func (ls *LayerBase) SetThread(thr int)

+ func (ls *LayerBase) SetType(typ emer.LayerType)

+ func (ls *LayerBase) Shape() *etensor.Shape

+ func (ls *LayerBase) Size() mat32.Vec2

+ func (ls *LayerBase) Thread() int

+ func (ls *LayerBase) Type() emer.LayerType

+ func (ls *LayerBase) TypeName() string

+ type NetworkBase struct

+ EmerNet emer.Network

+ FunTimes map[string]*timer.Time

+ LayClassMap map[string][]string

+ LayMap map[string]emer.Layer

+ Layers emer.Layers

+ LockThreads bool

+ MaxPos mat32.Vec3

+ MetaData map[string]string

+ MinPos mat32.Vec3

+ NThreads int

+ Nm string

+ ThrChans []LayFunChan

+ ThrLay [][]emer.Layer

+ ThrTimes []timer.Time

+ WaitGp sync.WaitGroup

+ WtsFile string

+ func (nt *NetworkBase) AddLayer(name string, shape []int, typ emer.LayerType) emer.Layer

+ func (nt *NetworkBase) AddLayer2D(name string, shapeY, shapeX int, typ emer.LayerType) emer.Layer

+ func (nt *NetworkBase) AddLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int, typ emer.LayerType) emer.Layer

+ func (nt *NetworkBase) AddLayerInit(ly emer.Layer, name string, shape []int, typ emer.LayerType)

+ func (nt *NetworkBase) AllParams() string

+ func (nt *NetworkBase) AllPrjnScales() string

+ func (nt *NetworkBase) ApplyParams(pars *params.Sheet, setMsg bool) (bool, error)

+ func (nt *NetworkBase) BidirConnectLayerNames(low, high string, pat prjn.Pattern) (lowlay, highlay emer.Layer, fwdpj, backpj emer.Prjn, err error)

+ func (nt *NetworkBase) BidirConnectLayers(low, high emer.Layer, pat prjn.Pattern) (fwdpj, backpj emer.Prjn)

+ func (nt *NetworkBase) BidirConnectLayersPy(low, high emer.Layer, pat prjn.Pattern)

+ func (nt *NetworkBase) Bounds() (min, max mat32.Vec3)

+ func (nt *NetworkBase) BoundsUpdt()

+ func (nt *NetworkBase) Build() error

+ func (nt *NetworkBase) BuildThreads()

+ func (nt *NetworkBase) ConnectLayerNames(send, recv string, pat prjn.Pattern, typ emer.PrjnType) (rlay, slay emer.Layer, pj emer.Prjn, err error)

+ func (nt *NetworkBase) ConnectLayers(send, recv emer.Layer, pat prjn.Pattern, typ emer.PrjnType) emer.Prjn

+ func (nt *NetworkBase) ConnectLayersPrjn(send, recv emer.Layer, pat prjn.Pattern, typ emer.PrjnType, pj emer.Prjn) emer.Prjn

+ func (nt *NetworkBase) DeleteAll()

+ func (nt *NetworkBase) FunTimerStart(fun string)

+ func (nt *NetworkBase) FunTimerStop(fun string)

+ func (nt *NetworkBase) InitName(net emer.Network, name string)

+ func (nt *NetworkBase) Label() string

+ func (nt *NetworkBase) LateralConnectLayer(lay emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *NetworkBase) LateralConnectLayerPrjn(lay emer.Layer, pat prjn.Pattern, pj emer.Prjn) emer.Prjn

+ func (nt *NetworkBase) Layer(idx int) emer.Layer

+ func (nt *NetworkBase) LayerByName(name string) emer.Layer

+ func (nt *NetworkBase) LayerByNameTry(name string) (emer.Layer, error)

+ func (nt *NetworkBase) LayersByClass(classes ...string) []string

+ func (nt *NetworkBase) Layout()

+ func (nt *NetworkBase) MakeLayMap()

+ func (nt *NetworkBase) NLayers() int

+ func (nt *NetworkBase) Name() string

+ func (nt *NetworkBase) NonDefaultParams() string

+ func (nt *NetworkBase) OpenWtsCpp(filename gi.FileName) error

+ func (nt *NetworkBase) OpenWtsJSON(filename gi.FileName) error

+ func (nt *NetworkBase) ReadWtsCpp(r io.Reader) error

+ func (nt *NetworkBase) ReadWtsJSON(r io.Reader) error

+ func (nt *NetworkBase) SaveWtsJSON(filename gi.FileName) error

+ func (nt *NetworkBase) SetWts(nw *weights.Network) error

+ func (nt *NetworkBase) StartThreads()

+ func (nt *NetworkBase) StdVertLayout()

+ func (nt *NetworkBase) StopThreads()

+ func (nt *NetworkBase) ThrLayFun(fun func(ly AxonLayer), funame string)

+ func (nt *NetworkBase) ThrTimerReset()

+ func (nt *NetworkBase) ThrWorker(tt int)

+ func (nt *NetworkBase) TimerReport()

+ func (nt *NetworkBase) VarRange(varNm string) (min, max float32, err error)

+ func (nt *NetworkBase) WriteWtsJSON(w io.Writer) error

Jun 9, 2022

Changes in this version

type Prjn

+ func (pj *Prjn) Syn1DNum() int

Jun 6, 2022

Changes in this version

+ func AgentSendActionAndStep(net *Network, ev agent.WorldInterface)

Jun 6, 2022

Changes in this version

+ func AgentApplyInputs(net *Network, en agent.WorldInterface, layerName string, ...)

+ func EnvApplyInputs(net *Network, ev env.Env)

Jun 6, 2022

Changes in this version

+ func LogAddDiagnosticItems(logs *elog.Logs, net *Network, times ...etime.Times)

+ func LogAddLayerActTensorItems(logs *elog.Logs, net *Network, mode etime.Modes, etm etime.Times)

+ func LogAddLayerGeActAvgItems(logs *elog.Logs, net *Network, mode etime.Modes, etm etime.Times)

+ func LogAddPCAItems(logs *elog.Logs, net *Network, times ...etime.Times)

+ func LogTestErrors(logs *elog.Logs)

+ func LooperResetLogBelow(man *looper.Manager, logs *elog.Logs)

+ func LooperSimCycleAndLearn(man *looper.Manager, net *Network, time *Time, netview *netview.ViewUpdt)

+ func LooperStdPhases(man *looper.Manager, time *Time, net *Network, plusStart, plusEnd int)

+ func LooperUpdtNetView(man *looper.Manager, netview *netview.ViewUpdt)

+ func LooperUpdtPlots(man *looper.Manager, gui *egui.GUI)

+ func PCAStats(net emer.Network, logs *elog.Logs, stats *estats.Stats)

+ func SaveWeightsIfArgSet(net *Network, args *ecmd.Args, ctrString, runName string)

+ func WeightsFileName(net *Network, ctrString, runName string) string

type AxonLayer

+ CorSimFmActs func()

+ type CorSimStats struct

+ Avg float32

+ Cor float32

+ Var float32

+ func (cd *CorSimStats) Init()

type Layer

+ CorSim CorSimStats

+ func (ly *Layer) CorSimFmActs()

May 17, 2022

Changes in this version

+ func AddCommonLogItemsForOutputLayers(ui *egui.UserInterface)

+ func AddDefaultLoopSimLogic(manager *looper.Manager, time *Time, net *Network)

+ func AddPlusAndMinusPhases(manager *looper.Manager, time *Time, net *Network)

+ func ApplyInputs(net *Network, en agent.WorldInterface, layer string, ...)

+ func HogDead(net *Network, lnm string) (hog, dead float64)

+ func NewRndSeed(randomSeed *int64)

+ func SaveWeights(fileName string, net *Network)

+ func SendActionAndStep(net *Network, ev agent.WorldInterface)

+ func SetParams(sheet string, setMsg bool, net *Network, params *params.Sets, paramName string, ...) error

+ func SetParamsSet(setNm string, sheet string, setMsg bool, net *Network, params *params.Sets, ...) error

+ func ToggleLayersOff(net *Network, layerNames []string, off bool)

May 12, 2022

Changes in this version

type Layer

+ func (ly *Layer) GScaleAvgs(ltime *Time)

Apr 14, 2022

Changes in this version

+ func AddCycle0(set *looper.Set, ltime *Time, name string, fun func())

+ func AddLoopCycle(set *looper.Set, name string, fun func())

+ func AddPhaseMain(set *looper.Set, name string, fun func())

+ func ConfigLoopsStd(set *looper.Set, net *Network, ltime *Time, minusCyc, plusCyc int)

+ func ConfigLoopsStdStack(st *looper.Stack, net *Network, ltime *Time, minusCyc, plusCyc int)

type Time

+ Mode string

+ Phase int

Mar 17, 2022

Changes in this version

type ActParams

+ func (ac *ActParams) GvgccFmVm(nrn *Neuron)

Mar 17, 2022

Changes in this version

type ActParams

+ AK chans.AKsParams

+ VGCC chans.VGCCParams

+ func (ac *ActParams) GeNoise(nrn *Neuron)

+ func (ac *ActParams) GiNoise(nrn *Neuron)

type NeurCaParams

+ Decay bool

type Neuron

+ Gak float32

+ Gvgcc float32

+ VgccCa float32

+ VgccH float32

+ VgccM float32

Mar 14, 2022

Changes in this version

type AxonPrjn

+ SendSynCa func(ltime *Time)

+ SynCaCont func(ltime *Time)

type Prjn

+ func (pj *Prjn) DWtCont(ltime *Time)

+ func (pj *Prjn) DWtNeurSpkTheta(ltime *Time)

+ func (pj *Prjn) DWtSynSpkTheta(ltime *Time)

+ func (pj *Prjn) SendSynCa(ltime *Time)

Mar 13, 2022

Changes in this version

+ func DecaySynCa(sy *Synapse, decay float32)

+ func InitSynCa(sy *Synapse)

Mar 13, 2022

Changes in this version

type AxonLayer

+ PostAct func(ltime *Time)

type Layer

+ func (ly *Layer) PostAct(ltime *Time)

type LearnSynParams

+ func (ls *LearnSynParams) KinaseTDWt(sy *Synapse)

type Network

+ func (nt *Network) PostAct(ltime *Time)

Mar 12, 2022

Changes in this version

type AxonLayer

+ RecvSynCa func(ltime *Time)

+ SynCaDWt func(ltime *Time)

type AxonPrjn

+ RecvSynCa func(ltime *Time)

type Layer

+ func (ly *Layer) RecvSynCa(ltime *Time)

+ func (ly *Layer) SynCaDWt(ltime *Time)

type LearnSynParams

+ KinaseCa kinase.CaParams

+ KinaseDWt kinase.DWtParams

type Network

+ SynDWtInterval int

type Prjn

+ func (pj *Prjn) RecvSynCa(ltime *Time)

Mar 12, 2022

Changes in this version

+ func InitCaSyn(sy *Synapse)

type LearnSynParams

+ func (ls *LearnSynParams) CaDMax(sy *Synapse)

type Synapse

+ CaUpT int32

Mar 12, 2022

Changes in this version

type AxonLayer

+ SynCa func(ltime *Time)

type AxonPrjn

+ SynCaDWt func(ltime *Time)

type LearnNeurParams

+ func (ln *LearnNeurParams) DecayNeurCa(nrn *Neuron, decay float32)

type LearnSynParams

+ func (ls *LearnSynParams) DWtFmTDWt(sy *Synapse, lr float32) bool

+ func (ls *LearnSynParams) SynSpkDWt(scap, scad float32) float32

type NeurCaParams

+ SynDWtInt int

type Neuron

+ PctDWt float32

type Prjn

+ func (pj *Prjn) SynCaDWt(ltime *Time)

type Synapse

+ CaDMax float32

+ TDWt float32

Mar 2, 2022

Changes in this version

type LearnNeurParams

+ LrnNMDA chans.NMDAParams

+ func (ln *LearnNeurParams) LrnNMDAFmRaw(nrn *Neuron, geExt float32)

type NeurCaParams

+ CaMax float32

+ CaThr float32

+ VGCCCa float32

+ func (np *NeurCaParams) CaNorm(ca float32) float32

Mar 1, 2022

Changes in this version

type Layer

+ DWtRaw minmax.AvgMax32

type NeurCaParams

+ LrnThr float32

+ SynSpkG float32

+ func (np *NeurCaParams) SynSpkCa(snCaSyn, rnCaSyn float32) float32

type Prjn

+ DWtRaw minmax.AvgMax32

Feb 28, 2022

Changes in this version

type LearnNeurParams

+ NeurCa NeurCaParams

+ func (ln *LearnNeurParams) InitNeurCa(nrn *Neuron)

+ type NeurCaParams struct

+ DDt float32

+ DTau float32

+ MDt float32

+ MTau float32

+ MinLrn float32

+ PDt float32

+ PTau float32

+ SpikeG float32

+ SynDt float32

+ SynTau float32

+ func (aa *NeurCaParams) CaFmSpike(spike float32, casyn, scam, scap, scad, capLrn, cadLrn *float32)

+ func (aa *NeurCaParams) Defaults()

+ func (aa *NeurCaParams) Update()

type Neuron

+ CaSyn float32

Feb 25, 2022

Changes in this version

type Time

+ Testing bool

Feb 23, 2022

Changes in this version

type Layer

+ func (ly *Layer) UnitValsRepTensor(tsr etensor.Tensor, varNm string) error

type LayerStru

+ RepIxs []int

+ func (ls *LayerStru) RepIdxs() []int

+ func (ls *LayerStru) SetRepIdxs(idxs []int)

Feb 22, 2022

Changes in this version

+ const SynapseVarStart

type AxonPrjn

+ RecvSynCaOpt func(ltime *Time)

type LearnNeurParams

+ Snmda chans.NMDAParams

+ SpikeCa SpikeCaParams

+ func (ln *LearnNeurParams) CaFmSpike(nrn *Neuron)

+ func (ln *LearnNeurParams) InitSpikeCa(nrn *Neuron)

type Neuron

+ CaD float32

+ CaDLrn float32

+ CaLrn float32

+ CaM float32

+ CaP float32

+ CaPLrn float32

type Prjn

+ func (pj *Prjn) RecvSynCaOpt(ltime *Time)

+ func (pj *Prjn) SynCaCont(ltime *Time)

+ func (pj *Prjn) SynCaOpt(ltime *Time)

type SWtParams

+ func (sp *SWtParams) InitWtsSyn(sy *Synapse, mean, spct float32)

+ type SpikeCaParams struct

+ DDt float32

+ DTau float32

+ LrnDt float32

+ LrnM float32

+ LrnS float32

+ LrnTau float32

+ MDt float32

+ MTau float32

+ MinLrn float32

+ PDt float32

+ PTau float32

+ SpikeG float32

+ func (aa *SpikeCaParams) CaFmSpike(spike float32, calrn, scam, scap, scad, capLrn, cadLrn *float32)

+ func (aa *SpikeCaParams) Defaults()

+ func (aa *SpikeCaParams) Update()

type Synapse

+ SpikeT int32

type XCalParams

+ On bool

+ PThrMin float32

Feb 15, 2022

Changes in this version

+ var KiT_KinaseRules = kit.Enums.AddEnum(KinaseRulesN, kit.NotBitFlag, nil)

+ type KinaseRules int32

+ const KinaseRulesN

+ const NeurSpkCa

+ const SynNMDACa

+ const SynSpkCa

+ func (ev *KinaseRules) UnmarshalJSON(b []byte) error

+ func (ev KinaseRules) MarshalJSON() ([]byte, error)

+ func (i *KinaseRules) FromString(s string) error

+ func (i KinaseRules) String() string

type KinaseSynParams

+ Rule KinaseRules

+ XCal bool

type NetworkStru

+ LayClassMap map[string][]string

+ func (nt *NetworkStru) LayersByClass(classes ...string) []string

type Prjn

+ func (pj *Prjn) DWtNeurSpkCa()

+ func (pj *Prjn) DWtSynNMDACa()

+ func (pj *Prjn) DWtSynSpkCa()

Feb 14, 2022

Changes in this version

type Layer

+ func (ly *Layer) DTrgSpkCaPubMean()

type LearnNeurParams

+ SpkCa SpkCaParams

+ func (ln *LearnNeurParams) InitSpkCa(nrn *Neuron)

+ func (ln *LearnNeurParams) SpkCaFmSpike(nrn *Neuron)

type NetworkStru

+ LayTypeMap map[emer.LayerType][]string

+ func (nt *NetworkStru) LayersByType(types ...emer.LayerType) []string

type Neuron

+ LrnCaD float32

+ LrnCaP float32

+ SpkCaD float32

+ SpkCaM float32

+ SpkCaP float32

+ type SpkCaParams struct

+ DDt float32

+ DTau float32

+ Init float32

+ LrnM float32

+ LrnS float32

+ MDt float32

+ MTau float32

+ MinLrn float32

+ PDt float32

+ PTau float32

+ SpikeG float32

+ func (aa *SpkCaParams) Defaults()

+ func (aa *SpkCaParams) SpkCaFmSpike(spike float32, scam, scap, scad, lrnCaP, lrnCaD *float32)

+ func (aa *SpkCaParams) Update()

Feb 10, 2022

Changes in this version

type DendParams

+ CaThr float32

+ func (dp *DendParams) CaNorm(ca float32) float32

+ type KinaseSynParams struct

+ DDt float32

+ DScale float32

+ DTau float32

+ MDt float32

+ MTau float32

+ On bool

+ PDt float32

+ PTau float32

+ SAvgThr float32

+ func (kp *KinaseSynParams) DWt(caP, caD float32) float32

+ func (kp *KinaseSynParams) Defaults()

+ func (kp *KinaseSynParams) FmCa(ca float32, caM, caP, caD *float32)

+ func (kp *KinaseSynParams) ResetCa(sy *Synapse)

+ func (kp *KinaseSynParams) Update()

type Neuron

+ RCa float32

Feb 9, 2022

Changes in this version

type ActParams

+ func (ac *ActParams) NMDAFmRaw(nrn *Neuron, geExt float32)

+ func (ac *ActParams) SenderGDecay(nrn *Neuron)

+ func (ac *ActParams) SenderGSpiked(nrn *Neuron)

type AxonPrjn

+ InitGBufs func()

+ SendESpike func(si int, sge, snmda float32)

+ SendISpike func(si int, sgi float32)

+ SynCa func()

type DendParams

+ CaMax float32

+ SeiDeplete bool

+ SnmdaDeplete bool

+ VGCCCa float32

+ type KinaseParams struct

+ DDt float32

+ DScale float32

+ DTau float32

+ MDt float32

+ MTau float32

+ On bool

+ PDt float32

+ PTau float32

+ SAvgThr float32

+ func (kp *KinaseParams) DWt(caP, caD float32) float32

+ func (kp *KinaseParams) Defaults()

+ func (kp *KinaseParams) FmCa(ca float32, caM, caP, caD *float32)

+ func (kp *KinaseParams) ResetCa(sy *Synapse)

+ func (kp *KinaseParams) Update()

type Layer

+ func (ly *Layer) SynCa()

type LearnSynParams

+ Kinase KinaseParams

type Neuron

+ GnmdaRaw float32

+ GnmdaSyn float32

+ Jca float32

+ RnmdaSyn float32

+ Se float32

+ Si float32

+ Snmda float32

+ SnmdaI float32

+ SnmdaO float32

type Prjn

+ AvgDWt float32

+ GBuf []float32

+ GnmdaBuf []float32

+ func (pj *Prjn) BuildGBufs()

+ func (pj *Prjn) DWtKinase()

+ func (pj *Prjn) DWtXCal()

+ func (pj *Prjn) InitGBufs()

+ func (pj *Prjn) SendESpike(si int, sge, snmda float32)

+ func (pj *Prjn) SendISpike(si int, sgi float32)

+ func (pj *Prjn) SynCa()

type Synapse

+ Ca float32

+ CaD float32

+ CaM float32

+ CaP float32

+ DWtRaw float32

Jan 16, 2022

Changes in this version

type DtParams

+ func (dp *DtParams) GeSynFmRaw(geRaw float32, geSyn *float32, min float32)

+ func (dp *DtParams) GiSynFmRaw(giRaw float32, giSyn *float32, min float32)

type Neuron

+ GeSyn float32

Jan 14, 2022

Changes in this version

type ActParams

+ func (ac *ActParams) VmInteg(vm, dt, ge, gl, gi, gk float32) (float32, float32)

type DtParams

+ DtStep float32

+ VmSteps int

Jan 13, 2022

Changes in this version

type ActParams

+ Dend DendParams

+ func (ac *ActParams) VmFmInet(vm, dt, inet float32) float32

+ type DendParams struct

+ GbarExp float32

+ GbarR float32

+ func (dp *DendParams) Defaults()

+ func (dp *DendParams) Update()

type NetworkStru

+ func (nt *NetworkStru) DeleteAll()

type SpikeParams

+ RDt float32

+ RTau float32

Dec 23, 2021

Changes in this version

type ClampParams

+ Add bool

type Network

+ func NewNetwork(name string) *Network

type Neuron

+ GeNoise float32

+ GeNoiseP float32

+ GiNoise float32

+ GiNoiseP float32

type Prjn

+ func (pj *Prjn) BuildGbuf()

+ type SpikeNoiseParams struct

+ Ge float32

+ GeExpInt float32

+ GeHz float32

+ Gi float32

+ GiExpInt float32

+ GiHz float32

+ On bool

+ func (an *SpikeNoiseParams) Defaults()

+ func (an *SpikeNoiseParams) PGe(p *float32) float32

+ func (an *SpikeNoiseParams) PGi(p *float32) float32

+ func (an *SpikeNoiseParams) Update()

Nov 22, 2021

Changes in this version

type AxonLayer

+ SynFail func()

type AxonPrjn

+ SynFail func()

type Layer

+ func (ly *Layer) SynFail()

type Network

+ func (nt *Network) InitGScale()

+ func (nt *Network) SynFail()

type Prjn

+ func (pj *Prjn) SynFail()

type SynComParams

+ PFailSWt bool

Nov 10, 2021

Changes in this version

+ type InhibMiscParams struct

+ AvgDt float32

+ AvgTau float32

+ GiSynThr float32

+ func (fb *InhibMiscParams) AvgAct(avg *float32, act float32)

+ func (fb *InhibMiscParams) Defaults()

+ func (fb *InhibMiscParams) GiSyn(gisyn float32) float32

+ func (fb *InhibMiscParams) Update()

type InhibParams

+ Inhib InhibMiscParams

type TopoInhibParams

+ WidthWt float32

+ Wrap bool

Nov 5, 2021

Changes in this version

type TrgAvgActParams

+ On bool

Oct 31, 2021

Changes in this version

type ActParams

+ Attn AttnParams

+ type AttnParams struct

+ Min float32

+ On bool

+ func (at *AttnParams) Defaults()

+ func (at *AttnParams) ModVal(val float32, attn float32) float32

+ func (at *AttnParams) Update()

type InhibParams

+ Topo TopoInhibParams

type Layer

+ func (ly *Layer) TopoGi(ltime *Time)

type Neuron

+ Attn float32

+ type TopoInhibParams struct

+ FB float32

+ FF float32

+ FF0 float32

+ Gi float32

+ On bool

+ Sigma float32

+ Width int

+ func (ti *TopoInhibParams) Defaults()

+ func (ti *TopoInhibParams) GiFmGeAct(ge, act, ff0 float32) float32

+ func (ti *TopoInhibParams) Update()

Aug 23, 2021

Changes in this version

type SWtAdaptParams

+ LWtMult float32

+ LWtNorm float32

+ LWtRange float32

Aug 14, 2021

Changes in this version

type SWtAdaptParams

+ CovarNeg bool

Aug 13, 2021

Changes in this version

type Neuron

+ Var float32

+ VarDif float32

type RLrateParams

+ CovarDt float32

+ CovarTau float32

type SWtAdaptParams

+ CovarLrate float32

type Synapse

+ Covar float32

Aug 13, 2021

Changes in this version

type Layer

+ func (ly *Layer) HasPoolInhib() bool

type LearnNeurParams

+ RLrate RLrateParams

type Neuron

+ RLrate float32

type PrjnScaleParams

+ Abs float32

+ type RLrateParams struct

+ ActDifThr float32

+ ActThr float32

+ Min float32

+ On bool

+ func (rl *RLrateParams) Defaults()

+ func (rl *RLrateParams) RLrate(avgS, avgM float32) float32

+ func (rl *RLrateParams) Update()

type TrgAvgActParams

+ Pool bool

Jul 24, 2021

Changes in this version

type Network

+ func (nt *Network) InitTopoSWts()

type Prjn

+ func (pj *Prjn) SetSWtsFunc(swtFun func(si, ri int, send, recv *etensor.Shape) float32)

+ func (pj *Prjn) SetSWtsRPool(swts etensor.Tensor)

type SWtParams

+ func (sp *SWtParams) ClipWt(wt float32) float32

Jun 17, 2021

Changes in this version

type FBActParams

+ Dt float32

+ Tau float32

Jun 13, 2021

Changes in this version

+ type FBActParams struct

+ DecayDt float32

+ DecayTau float32

+ RiseDt float32

+ RiseTau float32

+ func (fb *FBActParams) AvgAct(avg *float32, act float32)

+ func (fb *FBActParams) Defaults()

+ func (fb *FBActParams) Update()

type InhibParams

+ FBAct FBActParams

Jun 13, 2021

Changes in this version

type ActAvgParams

+ InhDt float32

+ InhTau float32

type ActParams

+ func (ac *ActParams) InitLongActs(nrn *Neuron)

type AxonLayer

+ InhibAct func(ltime *Time)

type DtParams

+ IntDt float32

+ IntTau float32

+ LongAvgDt float32

type Layer

+ func (ly *Layer) InhibAct(ltime *Time)

type Network

+ func (nt *Network) InhibAct(ltime *Time)

type Neuron

+ ActInt float32

type SpikeParams

+ ISIDt float32

+ ISITau float32

Jun 12, 2021

Changes in this version

type Layer

+ func (ly *Layer) ClearTargExt()

+ func (ly *Layer) TargToExt()

type Network

+ func (nt *Network) ClearTargExt()

+ func (nt *Network) TargToExt()

Jun 12, 2021

Changes in this version

type AxonLayer

+ ActSt1 func(ltime *Time)

+ ActSt2 func(ltime *Time)

+ MinusPhase func(ltime *Time)

+ NewState func()

+ PlusPhase func(ltime *Time)

type AxonNetwork

+ MinusPhaseImpl func(ltime *Time)

+ NewStateImpl func()

+ PlusPhaseImpl func(ltime *Time)

type DtParams

+ LongAvgTau float32

type Layer

+ func (ly *Layer) ActSt1(ltime *Time)

+ func (ly *Layer) ActSt2(ltime *Time)

+ func (ly *Layer) MinusPhase(ltime *Time)

+ func (ly *Layer) NewState()

+ func (ly *Layer) PlusPhase(ltime *Time)

type Network

+ func (nt *Network) ActSt1(ltime *Time)

+ func (nt *Network) ActSt2(ltime *Time)

+ func (nt *Network) MinusPhase(ltime *Time)

+ func (nt *Network) MinusPhaseImpl(ltime *Time)

+ func (nt *Network) NewState()

+ func (nt *Network) NewStateImpl()

+ func (nt *Network) PlusPhase(ltime *Time)

+ func (nt *Network) PlusPhaseImpl(ltime *Time)

type Neuron

+ ActPrv float32

+ ActSt1 float32

+ ActSt2 float32

type Time

+ PhaseCycle int

+ func (tm *Time) NewPhase()

+ func (tm *Time) NewState()

type TimeScales

+ const GammaCycle

Jun 5, 2021

Changes in this version

type LrnActAvgParams

+ MinLrn float32

type Neuron

+ AvgMLrn float32

Jun 2, 2021

Changes in this version

type Layer

+ func (ly *Layer) LrateMod(mod float32)

+ func (ly *Layer) LrateSched(sched float32)

+ type LrateMod struct

+ Base float32

+ On bool

+ Range minmax.F32

+ func (lr *LrateMod) Defaults()

+ func (lr *LrateMod) LrateMod(net *Network, fact float32) float32

+ func (lr *LrateMod) Mod(fact float32) float32

+ func (lr *LrateMod) Update()

+ type LrateParams struct

+ Base float32

+ Eff float32

+ Mod float32

+ Sched float32

+ func (ls *LrateParams) Defaults()

+ func (ls *LrateParams) Init()

+ func (ls *LrateParams) Update()

type Network

+ func (nt *Network) LrateMod(mod float32)

+ func (nt *Network) LrateSched(sched float32)

type Prjn

+ func (pj *Prjn) LrateMod(mod float32)

+ func (pj *Prjn) LrateSched(sched float32)

May 30, 2021

Changes in this version

type ActParams

+ Decay DecayParams

+ type DecayParams struct

+ Act float32

+ Glong float32

+ KNa float32

+ func (ai *DecayParams) Defaults()

+ func (ai *DecayParams) Update()

May 29, 2021

Changes in this version

type ActInitParams

+ GlongDecay float32

May 28, 2021

Changes in this version

type Time

+ func (tm *Time) TotalCycles() int

May 27, 2021

Changes in this version

type ActParams

+ func (ac *ActParams) BurstGe(cyc int, actm float32) float32

+ type ErrLrateMod struct

+ Base float32

+ Err float32

+ On bool

+ func (em *ErrLrateMod) Defaults()

+ func (em *ErrLrateMod) LrateMod(net *Network, err float32) float32

+ func (em *ErrLrateMod) Mod(err float32) float32

+ func (em *ErrLrateMod) Update()

type SWtAdaptParams

+ DreamVar float32

+ func (sp *SWtAdaptParams) RndVar() float32

type TrgAvgActParams

+ SynScaleRate float32

May 26, 2021

Changes in this version

type AxonLayer

+ LrateInit func(init, mult float32)

type AxonPrjn

+ LrateInit func(init, mult float32)

type Layer

+ func (ly *Layer) LrateInit(init, mult float32)

type Network

+ func (nt *Network) LrateInit(init, mult float32)

type Prjn

+ func (pj *Prjn) LrateInit(init, mult float32)

May 25, 2021

Changes in this version

type Synapse

+ DSWt float32

May 25, 2021

Changes in this version

type SWtAdaptParams

+ NoSScaleCred bool

May 24, 2021

Changes in this version

type SWtAdaptParams

+ WtSScaleCred bool

May 24, 2021

Changes in this version

type SWtAdaptParams

+ On bool

May 24, 2021

Changes in this version

type SWtAdaptParams

+ Targ bool

type SWtInitParams

+ TargSPct float32

type SWtParams

+ func (sp *SWtParams) LWtFmWts(wt, swt float32) float32

May 23, 2021

Changes in this version

type DtParams

+ func (dp *DtParams) AvgVarUpdt(avg, vr *float32, val float32)

type LearnNeurParams

+ TrgAvgAct TrgAvgActParams

type NetworkStru

+ func (nt *NetworkStru) AllPrjnScales() string

type Prjn

+ PrjnScale PrjnScaleParams

+ SWt SWtParams

+ SWtMeans []float32

+ func (pj *Prjn) SWtFmWt()

+ func (pj *Prjn) SWtRescale()

+ func (pj *Prjn) SWtRescaleDiv()

+ func (pj *Prjn) SWtRescaleSub()

+ type PrjnScaleParams struct

+ Adapt bool

+ AvgDt float32

+ AvgTau float32

+ HiTol float32

+ Init float32

+ LoTol float32

+ Rel float32

+ ScaleLrate float32

+ func (ws *PrjnScaleParams) Defaults()

+ func (ws *PrjnScaleParams) FullScale(savg, snu, ncon float32) float32

+ func (ws *PrjnScaleParams) SLayActScale(savg, snu, ncon float32) float32

+ func (ws *PrjnScaleParams) Update()

+ type SWtAdaptParams struct

+ Lrate float32

+ SigGain float32

+ SubNorm bool

+ func (sp *SWtAdaptParams) Defaults()

+ func (sp *SWtAdaptParams) Update()

+ type SWtInitParams struct

+ Mean float32

+ SPct float32

+ Sym bool

+ Var float32

+ func (sp *SWtInitParams) Defaults()

+ func (sp *SWtInitParams) RndVar() float32

+ func (sp *SWtInitParams) Update()

+ type SWtLimitParams struct

+ Mean minmax.F32

+ SWt minmax.F32

+ SoftBound bool

+ func (sp *SWtLimitParams) Defaults()

+ func (sp *SWtLimitParams) Update()

+ type SWtParams struct

+ Adapt SWtAdaptParams

+ Init SWtInitParams

+ Limit SWtLimitParams

+ func (sp *SWtParams) ClipSWt(swt float32) float32

+ func (sp *SWtParams) Defaults()

+ func (sp *SWtParams) LinFmSigWt(wt float32) float32

+ func (sp *SWtParams) SigFmLinWt(lw float32) float32

+ func (sp *SWtParams) Update()

+ func (sp *SWtParams) WtFmDWt(dwt, wt, lwt *float32, swt float32)

+ func (sp *SWtParams) WtVal(swt, lwt float32) float32

type Synapse

+ SWt float32

+ type TrgAvgActParams struct

+ ErrLrate float32

+ Permute bool

+ Rate float32

+ TrgRange minmax.F32

+ func (ss *TrgAvgActParams) Defaults()

+ func (ss *TrgAvgActParams) Update()

May 20, 2021

Changes in this version

+ type HebbPrjn struct

+ IncGain float32

+ func (pj *HebbPrjn) DWt()

+ func (pj *HebbPrjn) Defaults()

+ func (pj *HebbPrjn) UpdateParams()

May 18, 2021

Changes in this version

type DtParams

+ TrlAvgDt float32

+ TrlAvgTau float32

May 17, 2021

Changes in this version

type WtScaleParams

+ HiTol float32

+ LoTol float32

May 17, 2021

Changes in this version

type GScaleVals

+ AvgMaxRel float32

+ Err float32

type Layer

+ func (ly *Layer) AdaptGScale()

May 17, 2021

Changes in this version

type ActAvgParams

+ AdaptGi bool

+ AdaptRate float32

+ AvgDt float32

+ AvgTau float32

+ HiTol float32

+ LoTol float32

+ Targ float32

+ func (aa *ActAvgParams) Adapt(gimult *float32, trg, act float32) bool

type ActAvgVals

+ AvgMaxGeM float32

+ AvgMaxGiM float32

type ActParams

+ GTarg GTargParams

type AxonLayer

+ InitGScale func()

+ SlowAdapt func()

type AxonNetwork

+ SlowAdapt func()

type AxonPrjn

+ SlowAdapt func()

+ type GScaleVals struct

+ Avg float32

+ AvgAvg float32

+ AvgMax float32

+ Max float32

+ Orig float32

+ Rel float32

+ Scale float32

+ Targ float32

+ func (gs *GScaleVals) Init()

+ type GTargParams struct

+ GeMax float32

+ GiMax float32

+ func (gt *GTargParams) Defaults()

+ func (gt *GTargParams) Update()

type Layer

+ func (ly *Layer) AdaptInhib()

+ func (ly *Layer) InitGScale()

+ func (ly *Layer) SlowAdapt()

type Network

+ SlowCtr int

+ SlowInterval int

+ func (nt *Network) SlowAdapt()

type Neuron

+ GiM float32

type Pool

+ GiM minmax.AvgMax32

type Prjn

+ func (pj *Prjn) AdaptGScale()

+ func (pj *Prjn) RecvGIncNoStats()

+ func (pj *Prjn) RecvGIncStats()

+ func (pj *Prjn) SlowAdapt()

type WtScaleParams

+ Adapt bool

+ AvgDt float32

+ AvgTau float32

+ Init float32

+ ScaleLrate float32

May 15, 2021

Changes in this version

type WtSigParams

+ Min float32

May 14, 2021

Changes in this version

type ClampParams

+ Burst bool

May 13, 2021

Changes in this version

type ClampParams

+ BurstCyc int

+ BurstGe float32

+ BurstThr float32

May 13, 2021

Changes in this version

type InhibParams

+ Bg fffb.Bg

May 12, 2021

Changes in this version

+ type ActAvgVals struct

+ ActMAvg float32

+ ActPAvg float32

+ ActPAvgEff float32

+ GiAdaptCtr int

+ GiMult float32

type AxonLayer

+ IsInput func() bool

type Layer

+ ActAvg ActAvgVals

+ func (ly *Layer) DTrgAvgFmErr()

+ func (ly *Layer) DTrgAvgSubMean()

+ func (ly *Layer) IsInput() bool

+ func (ly *Layer) IsLearnTrgAvg() bool

+ func (ly *Layer) TrgAvgFmD()

+ func (ly *Layer) UpdateMPIRates(nmpi int)

type Network

+ func (nt *Network) UpdateMPIRates(nmpi int)

type Neuron

+ DTrgAvg float32

May 11, 2021

Changes in this version

type Time

+ PlusCyc int

+ func (tm *Time) CurCycles() int

May 11, 2021

Changes in this version

type Layer

+ func (ly *Layer) TrgAvgFmErr()

type SynScaleParams

+ ClipRange bool

type XCalParams

+ DWtThr float32

May 11, 2021

Changes in this version

+ var KiT_ActNoiseTypes = kit.Enums.AddEnum(ActNoiseTypesN, kit.NotBitFlag, nil)

+ var KiT_ClampTypes = kit.Enums.AddEnum(ClampTypesN, kit.NotBitFlag, nil)

+ type ActNoiseTypes int

+ const ActNoiseTypesN

+ func (ev *ActNoiseTypes) UnmarshalJSON(b []byte) error

+ func (ev ActNoiseTypes) MarshalJSON() ([]byte, error)

+ func (i *ActNoiseTypes) FromString(s string) error

+ func (i ActNoiseTypes) String() string

type ActParams

+ func (ac *ActParams) HasRateClamp(nrn *Neuron) bool

+ func (ac *ActParams) RateClamp(nrn *Neuron)

type AxonLayer

+ RateClamp func()

type ClampParams

+ Ge float32

+ Type ClampTypes

+ type ClampTypes int

+ const AddGeClamp

+ const ClampTypesN

+ const GeClamp

+ const RateClamp

+ func (ev *ClampTypes) UnmarshalJSON(b []byte) error

+ func (ev ClampTypes) MarshalJSON() ([]byte, error)

+ func (i *ClampTypes) FromString(s string) error

+ func (i ClampTypes) String() string

type Layer

+ func (ly *Layer) RateClamp()

May 10, 2021

Changes in this version

type SynScaleParams

+ ErrLrate float32

May 9, 2021

Changes in this version

type AxonLayer

+ DWtSubMean func()

+ SynScale func()

type AxonPrjn

+ DWtSubMean func()

+ SynScale func()

type Layer

+ func (ly *Layer) DWtSubMean()

+ func (ly *Layer) SynScale()

type LearnNeurParams

+ SynScale SynScaleParams

type Network

+ SynScaleCtr int

+ SynScaleInterval int

+ func (nt *Network) SynScale()

type Neuron

+ AvgDif float32

+ AvgPct float32

+ TrgAvg float32

type Pool

+ AvgDif minmax.AvgMax32

type Prjn

+ func (pj *Prjn) DWtSubMean()

+ func (pj *Prjn) SynScale()

+ type SynScaleParams struct

+ AvgDt float32

+ AvgTau float32

+ Permute bool

+ Rate float32

+ TrgRange minmax.F32

+ func (ss *SynScaleParams) Defaults()

+ func (ss *SynScaleParams) Update()

type XCalParams

+ SubMean float32

May 6, 2021

Changes in this version

type ActInitParams

+ KnaDecay float32

May 6, 2021

Changes in this version

type Layer

+ func (ly *Layer) AvgGeM(ltime *Time)

type Neuron

+ GeM float32

type Pool

+ GeM minmax.AvgMax32

Apr 28, 2021

Changes in this version

type InhibParams

+ AvgSS bool

Apr 27, 2021

Changes in this version

type WtBalParams

+ Targs bool

Apr 23, 2021

Changes in this version

type InhibParams

+ Adapt fffb.Adapt

type Layer

+ GiAdaptCtr int

+ GiMult float32

Apr 18, 2021

Changes in this version

+ const GitCommit

+ const NMDA

+ const NeuronVarStart

+ const Version

+ const VersionDate

+ var KiT_ActNoiseType = kit.Enums.AddEnum(ActNoiseTypeN, kit.NotBitFlag, nil)

+ var KiT_Layer = kit.Types.AddType(&Layer{}, LayerProps)

+ var KiT_NMDAPrjn = kit.Types.AddType(&NMDAPrjn{}, PrjnProps)

+ var KiT_Network = kit.Types.AddType(&Network{}, NetworkProps)

+ var KiT_NeurFlags = kit.Enums.AddEnum(NeurFlagsN, kit.BitFlag, nil)

+ var KiT_Prjn = kit.Types.AddType(&Prjn{}, PrjnProps)

+ var KiT_PrjnType = kit.Enums.AddEnumExt(emer.KiT_PrjnType, PrjnTypeN, kit.NotBitFlag, nil)

+ var KiT_Quarters = kit.Enums.AddEnum(QuartersN, kit.BitFlag, nil)

+ var KiT_TimeScales = kit.Enums.AddEnum(TimeScalesN, kit.NotBitFlag, nil)

+ var LayerProps = ki.Props

+ var NetworkProps = ki.Props

+ var NeuronVarProps = map[string]string

+ var NeuronVars = []string

+ var NeuronVarsMap map[string]int

+ var PrjnProps = ki.Props

+ var SynapseVarProps = map[string]string

+ var SynapseVars = []string

+ var SynapseVarsMap map[string]int

+ func JsonToParams(b []byte) string

+ func NeuronVarIdxByName(varNm string) (int, error)

+ func SigFun(w, gain, off float32) float32

+ func SigFun61(w float32) float32

+ func SigInvFun(w, gain, off float32) float32

+ func SigInvFun61(w float32) float32

+ func SynapseVarByName(varNm string) (int, error)

+ type ActAvg struct

+ ActMAvg float32

+ ActPAvg float32

+ ActPAvgEff float32

+ type ActAvgParams struct

+ Adjust float32

+ Dt float32

+ Fixed bool

+ Init float32

+ Tau float32

+ UseExtAct bool

+ UseFirst bool

+ func (aa *ActAvgParams) AvgFmAct(avg *float32, act float32)

+ func (aa *ActAvgParams) Defaults()

+ func (aa *ActAvgParams) EffFmAvg(eff *float32, avg float32)

+ func (aa *ActAvgParams) EffInit() float32

+ func (aa *ActAvgParams) Update()

+ type ActInitParams struct

+ Act float32

+ Decay float32

+ Ge float32

+ Gi float32

+ Vm float32

+ func (ai *ActInitParams) Defaults()

+ func (ai *ActInitParams) Update()

+ type ActNoiseParams struct

+ Fixed bool

+ Type ActNoiseType

+ func (an *ActNoiseParams) Defaults()

+ func (an *ActNoiseParams) Update()

+ type ActNoiseType int

+ const ActNoise

+ const ActNoiseTypeN

+ const GeMultNoise

+ const GeNoise

+ const NoNoise

+ const VmNoise

+ func (ev *ActNoiseType) UnmarshalJSON(b []byte) error

+ func (ev ActNoiseType) MarshalJSON() ([]byte, error)

+ func (i *ActNoiseType) FromString(s string) error

+ func (i ActNoiseType) String() string

+ type ActParams struct

+ Clamp ClampParams

+ Dt DtParams

+ Erev chans.Chans

+ GABAB glong.GABABParams

+ Gbar chans.Chans

+ Init ActInitParams

+ KNa knadapt.Params

+ NMDA glong.NMDAParams

+ Noise ActNoiseParams

+ Spike SpikeParams

+ VmRange minmax.F32

+ func (ac *ActParams) ActFmG(nrn *Neuron)

+ func (ac *ActParams) DecayState(nrn *Neuron, decay float32)

+ func (ac *ActParams) Defaults()

+ func (ac *ActParams) GeFmRaw(nrn *Neuron, geRaw float32)

+ func (ac *ActParams) GiFmRaw(nrn *Neuron, giRaw float32)

+ func (ac *ActParams) HardClamp(nrn *Neuron)

+ func (ac *ActParams) HasHardClamp(nrn *Neuron) bool

+ func (ac *ActParams) InetFmG(vm, ge, gi, gk float32) float32

+ func (ac *ActParams) InitActQs(nrn *Neuron)

+ func (ac *ActParams) InitActs(nrn *Neuron)

+ func (ac *ActParams) Update()

+ func (ac *ActParams) VmFmG(nrn *Neuron)

+ type AvgLParams struct

+ Dt float32

+ ErrMod bool

+ Gain float32

+ Init float32

+ LrnFact float32

+ LrnMax float32

+ LrnMin float32

+ Min float32

+ ModMin float32

+ Tau float32

+ func (al *AvgLParams) AvgLFmAvgM(avgM float32, avgL, lrn *float32)

+ func (al *AvgLParams) Defaults()

+ func (al *AvgLParams) ErrModFmLayErr(layCosDiffAvg float32) float32

+ func (al *AvgLParams) Update()

+ type AxonLayer interface

+ ActFmG func(ltime *Time)

+ AlphaCycInit func()

+ ApplyExt func(ext etensor.Tensor)

+ ApplyExt1D func(ext []float64)

+ AsAxon func() *Layer

+ AvgLFmAvgM func()

+ AvgMaxAct func(ltime *Time)

+ AvgMaxGe func(ltime *Time)

+ CosDiffFmActs func()

+ CyclePost func(ltime *Time)

+ DWt func()

+ DecayState func(decay float32)

+ GFmInc func(ltime *Time)

+ GScaleFmAvgAct func()

+ GenNoise func()

+ HardClamp func()

+ InhibFmGeAct func(ltime *Time)

+ InitActAvg func()

+ InitActs func()

+ InitExt func()

+ InitWtSym func()

+ InitWts func()

+ IsTarget func() bool

+ LrateMult func(mult float32)

+ QuarterFinal func(ltime *Time)

+ SendSpike func(ltime *Time)

+ UpdateExtFlags func()

+ WtBalFmWt func()

+ WtFmDWt func()

+ type AxonNetwork interface

+ AlphaCycInitImpl func()

+ AsAxon func() *Network

+ CycleImpl func(ltime *Time)

+ CyclePostImpl func(ltime *Time)

+ DWtImpl func()

+ QuarterFinalImpl func(ltime *Time)

+ WtFmDWtImpl func()

+ type AxonPrjn interface

+ AsAxon func() *Prjn

+ DWt func()

+ InitGbuf func()

+ InitWtSym func(rpj AxonPrjn)

+ InitWts func()

+ LrateMult func(mult float32)

+ RecvGInc func()

+ SendSpike func(si int)

+ WtBalFmWt func()

+ WtFmDWt func()

+ type ClampParams struct

+ Avg bool

+ AvgGain float32

+ ErrThr float32

+ Gain float32

+ Hard bool

+ Rate float32

+ func (cp *ClampParams) AvgGe(ext, ge float32) float32

+ func (cp *ClampParams) Defaults()

+ func (cp *ClampParams) Update()

+ type CosDiffParams struct

+ Dt float32

+ DtC float32

+ Tau float32

+ func (cd *CosDiffParams) AvgVarFmCos(avg, vr *float32, cos float32)

+ func (cd *CosDiffParams) Defaults()

+ func (cd *CosDiffParams) Update()

+ type CosDiffStats struct

+ Avg float32

+ AvgLrn float32

+ Cos float32

+ ModAvgLLrn float32

+ Var float32

+ func (cd *CosDiffStats) Init()

+ type DWtNormParams struct

+ DecayDt float32

+ DecayDtC float32

+ DecayTau float32

+ LrComp float32

+ NormMin float32

+ On bool

+ Stats bool

+ func (dn *DWtNormParams) Defaults()

+ func (dn *DWtNormParams) NormFmAbsDWt(norm *float32, absDwt float32) float32

+ func (dn *DWtNormParams) Update()

+ type DtParams struct

+ AvgDt float32

+ AvgTau float32

+ GeDt float32

+ GeTau float32

+ GiDt float32

+ GiTau float32

+ Integ float32

+ MDt float32

+ MTau float32

+ VmDendDt float32

+ VmDendTau float32

+ VmDt float32

+ VmTau float32

+ func (dp *DtParams) Defaults()

+ func (dp *DtParams) GeFmRaw(geRaw float32, ge *float32, min float32)

+ func (dp *DtParams) GiFmRaw(giRaw float32, gi *float32, min float32)

+ func (dp *DtParams) Update()

+ type InhibParams struct

+ ActAvg ActAvgParams

+ Layer fffb.Params

+ Pool fffb.Params

+ Self SelfInhibParams

+ func (ip *InhibParams) Defaults()

+ func (ip *InhibParams) Update()

+ type LayFunChan chan func(ly AxonLayer)

+ type Layer struct

+ Act ActParams

+ CosDiff CosDiffStats

+ Inhib InhibParams

+ Learn LearnNeurParams

+ Neurons []Neuron

+ Pools []Pool

+ func (ly *Layer) ActFmG(ltime *Time)

+ func (ly *Layer) AllParams() string

+ func (ly *Layer) AlphaCycInit()

+ func (ly *Layer) ApplyExt(ext etensor.Tensor)

+ func (ly *Layer) ApplyExt1D(ext []float64)

+ func (ly *Layer) ApplyExt1D32(ext []float32)

+ func (ly *Layer) ApplyExt1DTsr(ext etensor.Tensor)

+ func (ly *Layer) ApplyExt2D(ext etensor.Tensor)

+ func (ly *Layer) ApplyExt2Dto4D(ext etensor.Tensor)

+ func (ly *Layer) ApplyExt4D(ext etensor.Tensor)

+ func (ly *Layer) ApplyExtFlags() (clrmsk, setmsk int32, toTarg bool)

+ func (ly *Layer) AsAxon() *Layer

+ func (ly *Layer) AvgLFmAvgM()

+ func (ly *Layer) AvgMaxAct(ltime *Time)

+ func (ly *Layer) AvgMaxGe(ltime *Time)

+ func (ly *Layer) Build() error

+ func (ly *Layer) BuildPools(nu int) error

+ func (ly *Layer) BuildPrjns() error

+ func (ly *Layer) BuildSubPools()

+ func (ly *Layer) CosDiffFmActs()

+ func (ly *Layer) CostEst() (neur, syn, tot int)

+ func (ly *Layer) CyclePost(ltime *Time)

+ func (ly *Layer) DWt()

+ func (ly *Layer) DecayState(decay float32)

+ func (ly *Layer) DecayStatePool(pool int, decay float32)

+ func (ly *Layer) Defaults()

+ func (ly *Layer) GFmInc(ltime *Time)

+ func (ly *Layer) GFmIncNeur(ltime *Time)

+ func (ly *Layer) GScaleFmAvgAct()

+ func (ly *Layer) GenNoise()

+ func (ly *Layer) HardClamp()

+ func (ly *Layer) InhibFmGeAct(ltime *Time)

+ func (ly *Layer) InhibFmPool(ltime *Time)

+ func (ly *Layer) InitActAvg()

+ func (ly *Layer) InitActs()

+ func (ly *Layer) InitExt()

+ func (ly *Layer) InitWtSym()

+ func (ly *Layer) InitWts()

+ func (ly *Layer) IsTarget() bool

+ func (ly *Layer) LesionNeurons(prop float32) int

+ func (ly *Layer) LrateMult(mult float32)

+ func (ly *Layer) PctUnitErr() float64

+ func (ly *Layer) Pool(idx int) *Pool

+ func (ly *Layer) PoolInhibFmGeAct(ltime *Time)

+ func (ly *Layer) PoolTry(idx int) (*Pool, error)

+ func (ly *Layer) QuarterFinal(ltime *Time)

+ func (ly *Layer) ReadWtsJSON(r io.Reader) error

+ func (ly *Layer) RecvGInc(ltime *Time)

+ func (ly *Layer) RecvPrjnVals(vals *[]float32, varNm string, sendLay emer.Layer, sendIdx1D int, ...) error

+ func (ly *Layer) SendPrjnVals(vals *[]float32, varNm string, recvLay emer.Layer, recvIdx1D int, ...) error

+ func (ly *Layer) SendSpike(ltime *Time)

+ func (ly *Layer) SetWts(lw *weights.Layer) error

+ func (ly *Layer) UnLesionNeurons()

+ func (ly *Layer) UnitVal(varNm string, idx []int) float32

+ func (ly *Layer) UnitVal1D(varIdx int, idx int) float32

+ func (ly *Layer) UnitVals(vals *[]float32, varNm string) error

+ func (ly *Layer) UnitValsTensor(tsr etensor.Tensor, varNm string) error

+ func (ly *Layer) UnitVarIdx(varNm string) (int, error)

+ func (ly *Layer) UnitVarNames() []string

+ func (ly *Layer) UnitVarNum() int

+ func (ly *Layer) UnitVarProps() map[string]string

+ func (ly *Layer) UpdateExtFlags()

+ func (ly *Layer) UpdateParams()

+ func (ly *Layer) VarRange(varNm string) (min, max float32, err error)

+ func (ly *Layer) WriteWtsJSON(w io.Writer, depth int)

+ func (ly *Layer) WtBalFmWt()

+ func (ly *Layer) WtFmDWt()

+ type LayerStru struct

+ AxonLay AxonLayer

+ Cls string

+ Idx int

+ Network emer.Network

+ Nm string

+ Off bool

+ Ps mat32.Vec3

+ RcvPrjns emer.Prjns

+ Rel relpos.Rel

+ Shp etensor.Shape

+ SndPrjns emer.Prjns

+ Thr int

+ Typ emer.LayerType

+ func (ls *LayerStru) ApplyParams(pars *params.Sheet, setMsg bool) (bool, error)

+ func (ls *LayerStru) Class() string

+ func (ls *LayerStru) Config(shape []int, typ emer.LayerType)

+ func (ls *LayerStru) Idx4DFrom2D(x, y int) ([]int, bool)

+ func (ls *LayerStru) Index() int

+ func (ls *LayerStru) InitName(lay emer.Layer, name string, net emer.Network)

+ func (ls *LayerStru) Is2D() bool

+ func (ls *LayerStru) Is4D() bool

+ func (ls *LayerStru) IsOff() bool

+ func (ls *LayerStru) Label() string

+ func (ls *LayerStru) NPools() int

+ func (ls *LayerStru) NRecvPrjns() int

+ func (ls *LayerStru) NSendPrjns() int

+ func (ls *LayerStru) Name() string

+ func (ls *LayerStru) NonDefaultParams() string

+ func (ls *LayerStru) Pos() mat32.Vec3

+ func (ls *LayerStru) RecipToSendPrjn(spj emer.Prjn) (emer.Prjn, bool)

+ func (ls *LayerStru) RecvPrjn(idx int) emer.Prjn

+ func (ls *LayerStru) RecvPrjns() *emer.Prjns

+ func (ls *LayerStru) RelPos() relpos.Rel

+ func (ls *LayerStru) SendPrjn(idx int) emer.Prjn

+ func (ls *LayerStru) SendPrjns() *emer.Prjns

+ func (ls *LayerStru) SetClass(cls string)

+ func (ls *LayerStru) SetIndex(idx int)

+ func (ls *LayerStru) SetName(nm string)

+ func (ls *LayerStru) SetOff(off bool)

+ func (ls *LayerStru) SetPos(pos mat32.Vec3)

+ func (ls *LayerStru) SetRelPos(rel relpos.Rel)

+ func (ls *LayerStru) SetShape(shape []int)

+ func (ls *LayerStru) SetThread(thr int)

+ func (ls *LayerStru) SetType(typ emer.LayerType)

+ func (ls *LayerStru) Shape() *etensor.Shape

+ func (ls *LayerStru) Size() mat32.Vec2

+ func (ls *LayerStru) Thread() int

+ func (ls *LayerStru) Type() emer.LayerType

+ func (ls *LayerStru) TypeName() string

+ type LearnNeurParams struct

+ ActAvg LrnActAvgParams

+ AvgL AvgLParams

+ CosDiff CosDiffParams

+ func (ln *LearnNeurParams) AvgLFmAvgM(nrn *Neuron)

+ func (ln *LearnNeurParams) AvgsFmAct(nrn *Neuron)

+ func (ln *LearnNeurParams) Defaults()

+ func (ln *LearnNeurParams) InitActAvg(nrn *Neuron)

+ func (ln *LearnNeurParams) Update()

+ type LearnSynParams struct

+ Learn bool

+ Lrate float32

+ LrateInit float32

+ Momentum MomentumParams

+ Norm DWtNormParams

+ WtBal WtBalParams

+ WtSig WtSigParams

+ XCal XCalParams

+ func (ls *LearnSynParams) BCMdWt(suAvgSLrn, ruAvgSLrn, ruAvgL float32) float32

+ func (ls *LearnSynParams) CHLdWt(suAvgSLrn, suAvgM, ruAvgSLrn, ruAvgM, ruAvgL float32) (err, bcm float32)

+ func (ls *LearnSynParams) Defaults()

+ func (ls *LearnSynParams) LWtFmWt(syn *Synapse)

+ func (ls *LearnSynParams) Update()

+ func (ls *LearnSynParams) WtFmDWt(wbInc, wbDec float32, dwt, wt, lwt *float32, scale float32)

+ func (ls *LearnSynParams) WtFmLWt(syn *Synapse)

+ type LrnActAvgParams struct

+ Init float32

+ LrnM float32

+ LrnS float32

+ MDt float32

+ MTau float32

+ SDt float32

+ SSDt float32

+ SSTau float32

+ STau float32

+ SpikeG float32

+ func (aa *LrnActAvgParams) AvgsFmAct(act float32, avgSS, avgS, avgM, avgSLrn *float32)

+ func (aa *LrnActAvgParams) Defaults()

+ func (aa *LrnActAvgParams) Update()

+ type MomentumParams struct

+ LrComp float32

+ MDt float32

+ MDtC float32

+ MTau float32

+ On bool

+ func (mp *MomentumParams) Defaults()

+ func (mp *MomentumParams) MomentFmDWt(moment *float32, dwt float32) float32

+ func (mp *MomentumParams) Update()

+ type NMDAPrjn struct

+ func (pj *NMDAPrjn) PrjnTypeName() string

+ func (pj *NMDAPrjn) Type() emer.PrjnType

+ func (pj *NMDAPrjn) UpdateParams()

+ type Network struct

+ WtBalCtr int

+ WtBalInterval int

+ func (nt *Network) ActFmG(ltime *Time)

+ func (nt *Network) AlphaCycInit()

+ func (nt *Network) AlphaCycInitImpl()

+ func (nt *Network) AsAxon() *Network

+ func (nt *Network) AvgMaxAct(ltime *Time)

+ func (nt *Network) AvgMaxGe(ltime *Time)

+ func (nt *Network) CollectDWts(dwts *[]float32, nwts int) bool

+ func (nt *Network) Cycle(ltime *Time)

+ func (nt *Network) CycleImpl(ltime *Time)

+ func (nt *Network) CyclePost(ltime *Time)

+ func (nt *Network) CyclePostImpl(ltime *Time)

+ func (nt *Network) DWt()

+ func (nt *Network) DWtImpl()

+ func (nt *Network) DecayState(decay float32)

+ func (nt *Network) Defaults()

+ func (nt *Network) GScaleFmAvgAct()

+ func (nt *Network) InhibFmGeAct(ltime *Time)

+ func (nt *Network) InitActs()

+ func (nt *Network) InitExt()

+ func (nt *Network) InitTopoScales()

+ func (nt *Network) InitWts()

+ func (nt *Network) LayersSetOff(off bool)

+ func (nt *Network) LrateMult(mult float32)

+ func (nt *Network) NewLayer() emer.Layer

+ func (nt *Network) NewPrjn() emer.Prjn

+ func (nt *Network) QuarterFinal(ltime *Time)

+ func (nt *Network) QuarterFinalImpl(ltime *Time)

+ func (nt *Network) SendSpike(ltime *Time)

+ func (nt *Network) SetDWts(dwts []float32)

+ func (nt *Network) SizeReport() string

+ func (nt *Network) SynVarNames() []string

+ func (nt *Network) SynVarProps() map[string]string

+ func (nt *Network) ThreadAlloc(nThread int) string

+ func (nt *Network) ThreadReport() string

+ func (nt *Network) UnLesionNeurons()

+ func (nt *Network) UnitVarNames() []string

+ func (nt *Network) UnitVarProps() map[string]string

+ func (nt *Network) UpdateExtFlags()

+ func (nt *Network) UpdateParams()

+ func (nt *Network) WtBalFmWt()

+ func (nt *Network) WtFmDWt()

+ func (nt *Network) WtFmDWtImpl()

+ type NetworkStru struct

+ EmerNet emer.Network

+ FunTimes map[string]*timer.Time

+ LayMap map[string]emer.Layer

+ Layers emer.Layers

+ LockThreads bool

+ MaxPos mat32.Vec3

+ MetaData map[string]string

+ MinPos mat32.Vec3

+ NThreads int

+ Nm string

+ ThrChans []LayFunChan

+ ThrLay [][]emer.Layer

+ ThrTimes []timer.Time

+ WaitGp sync.WaitGroup

+ WtsFile string

+ func (nt *NetworkStru) AddLayer(name string, shape []int, typ emer.LayerType) emer.Layer

+ func (nt *NetworkStru) AddLayer2D(name string, shapeY, shapeX int, typ emer.LayerType) emer.Layer

+ func (nt *NetworkStru) AddLayer4D(name string, nPoolsY, nPoolsX, nNeurY, nNeurX int, typ emer.LayerType) emer.Layer

+ func (nt *NetworkStru) AddLayerInit(ly emer.Layer, name string, shape []int, typ emer.LayerType)

+ func (nt *NetworkStru) AllParams() string

+ func (nt *NetworkStru) AllWtScales() string

+ func (nt *NetworkStru) ApplyParams(pars *params.Sheet, setMsg bool) (bool, error)

+ func (nt *NetworkStru) BidirConnectLayerNames(low, high string, pat prjn.Pattern) (lowlay, highlay emer.Layer, fwdpj, backpj emer.Prjn, err error)

+ func (nt *NetworkStru) BidirConnectLayers(low, high emer.Layer, pat prjn.Pattern) (fwdpj, backpj emer.Prjn)

+ func (nt *NetworkStru) BidirConnectLayersPy(low, high emer.Layer, pat prjn.Pattern)

+ func (nt *NetworkStru) Bounds() (min, max mat32.Vec3)

+ func (nt *NetworkStru) BoundsUpdt()

+ func (nt *NetworkStru) Build() error

+ func (nt *NetworkStru) BuildThreads()

+ func (nt *NetworkStru) ConnectLayerNames(send, recv string, pat prjn.Pattern, typ emer.PrjnType) (rlay, slay emer.Layer, pj emer.Prjn, err error)

+ func (nt *NetworkStru) ConnectLayers(send, recv emer.Layer, pat prjn.Pattern, typ emer.PrjnType) emer.Prjn

+ func (nt *NetworkStru) ConnectLayersPrjn(send, recv emer.Layer, pat prjn.Pattern, typ emer.PrjnType, pj emer.Prjn) emer.Prjn

+ func (nt *NetworkStru) FunTimerStart(fun string)

+ func (nt *NetworkStru) FunTimerStop(fun string)

+ func (nt *NetworkStru) InitName(net emer.Network, name string)

+ func (nt *NetworkStru) Label() string

+ func (nt *NetworkStru) LateralConnectLayer(lay emer.Layer, pat prjn.Pattern) emer.Prjn

+ func (nt *NetworkStru) LateralConnectLayerPrjn(lay emer.Layer, pat prjn.Pattern, pj emer.Prjn) emer.Prjn

+ func (nt *NetworkStru) Layer(idx int) emer.Layer

+ func (nt *NetworkStru) LayerByName(name string) emer.Layer

+ func (nt *NetworkStru) LayerByNameTry(name string) (emer.Layer, error)

+ func (nt *NetworkStru) Layout()

+ func (nt *NetworkStru) MakeLayMap()

+ func (nt *NetworkStru) NLayers() int

+ func (nt *NetworkStru) Name() string

+ func (nt *NetworkStru) NonDefaultParams() string

+ func (nt *NetworkStru) OpenWtsCpp(filename gi.FileName) error

+ func (nt *NetworkStru) OpenWtsJSON(filename gi.FileName) error

+ func (nt *NetworkStru) ReadWtsCpp(r io.Reader) error

+ func (nt *NetworkStru) ReadWtsJSON(r io.Reader) error

+ func (nt *NetworkStru) SaveWtsJSON(filename gi.FileName) error

+ func (nt *NetworkStru) SetWts(nw *weights.Network) error

+ func (nt *NetworkStru) StartThreads()

+ func (nt *NetworkStru) StdVertLayout()

+ func (nt *NetworkStru) StopThreads()

+ func (nt *NetworkStru) ThrLayFun(fun func(ly AxonLayer), funame string)

+ func (nt *NetworkStru) ThrTimerReset()

+ func (nt *NetworkStru) ThrWorker(tt int)

+ func (nt *NetworkStru) TimerReport()

+ func (nt *NetworkStru) VarRange(varNm string) (min, max float32, err error)

+ func (nt *NetworkStru) WriteWtsJSON(w io.Writer) error

+ type NeurFlags int32

+ const NeurFlagsN

+ const NeurHasCmpr

+ const NeurHasExt

+ const NeurHasTarg

+ const NeurOff

+ func (ev *NeurFlags) UnmarshalJSON(b []byte) error

+ func (ev NeurFlags) MarshalJSON() ([]byte, error)

+ func (i *NeurFlags) FromString(s string) error

+ func (i NeurFlags) String() string

+ type Neuron struct

+ Act float32

+ ActAvg float32

+ ActDel float32

+ ActDif float32

+ ActLrn float32

+ ActM float32

+ ActP float32

+ ActQ0 float32

+ ActQ1 float32

+ ActQ2 float32

+ AvgL float32

+ AvgLLrn float32

+ AvgM float32

+ AvgS float32

+ AvgSLrn float32

+ AvgSS float32

+ Ext float32

+ Flags NeurFlags

+ GABAB float32

+ GABABx float32

+ Ge float32

+ GeRaw float32

+ GgabaB float32

+ Gi float32

+ GiRaw float32

+ GiSelf float32

+ GiSyn float32

+ Gk float32

+ GknaFast float32

+ GknaMed float32

+ GknaSlow float32

+ Gnmda float32

+ ISI float32

+ ISIAvg float32

+ Inet float32

+ NMDA float32

+ NMDASyn float32

+ Noise float32

+ Spike float32

+ SubPool int32

+ Targ float32

+ Vm float32

+ VmDend float32

+ func (nrn *Neuron) ClearFlag(flag NeurFlags)

+ func (nrn *Neuron) ClearMask(mask int32)

+ func (nrn *Neuron) HasFlag(flag NeurFlags) bool

+ func (nrn *Neuron) IsOff() bool

+ func (nrn *Neuron) SetFlag(flag NeurFlags)

+ func (nrn *Neuron) SetMask(mask int32)

+ func (nrn *Neuron) VarByIndex(idx int) float32

+ func (nrn *Neuron) VarByName(varNm string) (float32, error)

+ func (nrn *Neuron) VarNames() []string

+ type Pool struct

+ ActAvg ActAvg

+ ActM minmax.AvgMax32

+ ActP minmax.AvgMax32

+ EdIdx int

+ Inhib fffb.Inhib

+ StIdx int

+ func (pl *Pool) Init()

+ type Prjn struct

+ Com SynComParams

+ GScale float32

+ Gbuf []float32

+ Gidx ringidx.FIx

+ Learn LearnSynParams

+ Syns []Synapse

+ WbRecv []WtBalRecvPrjn

+ WtInit WtInitParams

+ WtScale WtScaleParams

+ func (pj *Prjn) AllParams() string

+ func (pj *Prjn) AsAxon() *Prjn

+ func (pj *Prjn) Build() error

+ func (pj *Prjn) DWt()

+ func (pj *Prjn) Defaults()

+ func (pj *Prjn) InitGbuf()

+ func (pj *Prjn) InitWtSym(rpjp AxonPrjn)

+ func (pj *Prjn) InitWts()

+ func (pj *Prjn) InitWtsSyn(syn *Synapse)

+ func (pj *Prjn) LrateMult(mult float32)

+ func (pj *Prjn) ReadWtsJSON(r io.Reader) error

+ func (pj *Prjn) RecvGInc()

+ func (pj *Prjn) SendSpike(si int)

+ func (pj *Prjn) SetClass(cls string) emer.Prjn

+ func (pj *Prjn) SetPattern(pat prjn.Pattern) emer.Prjn

+ func (pj *Prjn) SetScalesFunc(scaleFun func(si, ri int, send, recv *etensor.Shape) float32)

+ func (pj *Prjn) SetScalesRPool(scales etensor.Tensor)

+ func (pj *Prjn) SetSynVal(varNm string, sidx, ridx int, val float32) error

+ func (pj *Prjn) SetType(typ emer.PrjnType) emer.Prjn

+ func (pj *Prjn) SetWts(pw *weights.Prjn) error

+ func (pj *Prjn) SetWtsFunc(wtFun func(si, ri int, send, recv *etensor.Shape) float32)

+ func (pj *Prjn) SynIdx(sidx, ridx int) int

+ func (pj *Prjn) SynVal(varNm string, sidx, ridx int) float32

+ func (pj *Prjn) SynVal1D(varIdx int, synIdx int) float32

+ func (pj *Prjn) SynVals(vals *[]float32, varNm string) error

+ func (pj *Prjn) SynVarIdx(varNm string) (int, error)

+ func (pj *Prjn) SynVarNames() []string

+ func (pj *Prjn) SynVarNum() int

+ func (pj *Prjn) SynVarProps() map[string]string

+ func (pj *Prjn) UpdateParams()

+ func (pj *Prjn) WriteWtsJSON(w io.Writer, depth int)

+ func (pj *Prjn) WtBalFmWt()

+ func (pj *Prjn) WtFmDWt()

+ type PrjnStru struct

+ AxonPrj AxonPrjn

+ Cls string

+ Notes string

+ Off bool

+ Pat prjn.Pattern

+ RConIdx []int32

+ RConIdxSt []int32

+ RConN []int32

+ RConNAvgMax minmax.AvgMax32

+ RSynIdx []int32

+ Recv emer.Layer

+ SConIdx []int32

+ SConIdxSt []int32

+ SConN []int32

+ SConNAvgMax minmax.AvgMax32

+ Send emer.Layer

+ Typ emer.PrjnType

+ func (ps *PrjnStru) ApplyParams(pars *params.Sheet, setMsg bool) (bool, error)

+ func (ps *PrjnStru) BuildStru() error

+ func (ps *PrjnStru) Class() string

+ func (ps *PrjnStru) Connect(slay, rlay emer.Layer, pat prjn.Pattern, typ emer.PrjnType)

+ func (ps *PrjnStru) Init(prjn emer.Prjn)

+ func (ps *PrjnStru) IsOff() bool

+ func (ps *PrjnStru) Label() string

+ func (ps *PrjnStru) Name() string

+ func (ps *PrjnStru) NonDefaultParams() string

+ func (ps *PrjnStru) Pattern() prjn.Pattern

+ func (ps *PrjnStru) PrjnTypeName() string

+ func (ps *PrjnStru) RecvLay() emer.Layer

+ func (ps *PrjnStru) SendLay() emer.Layer

+ func (ps *PrjnStru) SetNIdxSt(n *[]int32, avgmax *minmax.AvgMax32, idxst *[]int32, tn *etensor.Int32) int32

+ func (ps *PrjnStru) SetOff(off bool)

+ func (ps *PrjnStru) String() string

+ func (ps *PrjnStru) Type() emer.PrjnType

+ func (ps *PrjnStru) TypeName() string

+ func (ps *PrjnStru) Validate(logmsg bool) error

+ type PrjnType emer.PrjnType

+ const NMDA_

+ const PrjnTypeN

+ func StringToPrjnType(s string) (PrjnType, error)

+ func (i PrjnType) String() string

+ type Quarters int32

+ const Q1

+ const Q2

+ const Q3

+ const Q4

+ const QuartersN

+ func (i *Quarters) FromString(s string) error

+ func (i Quarters) String() string

+ func (qt *Quarters) Clear(qtr int)

+ func (qt *Quarters) Set(qtr int)

+ func (qt *Quarters) UnmarshalJSON(b []byte) error

+ func (qt Quarters) Has(qtr int) bool

+ func (qt Quarters) HasNext(qtr int) bool

+ func (qt Quarters) HasPrev(qtr int) bool

+ func (qt Quarters) MarshalJSON() ([]byte, error)

+ type SelfInhibParams struct

+ Dt float32

+ Gi float32

+ On bool

+ Tau float32

+ func (si *SelfInhibParams) Defaults()

+ func (si *SelfInhibParams) Inhib(self *float32, act float32)

+ func (si *SelfInhibParams) Update()

+ type SpikeParams struct

+ Exp bool

+ ExpSlope float32

+ ExpThr float32

+ MaxHz float32

+ RateDt float32

+ RateTau float32

+ Thr float32

+ Tr int

+ VmR float32

+ func (sk *SpikeParams) ActFmISI(isi, timeInc, integ float32) float32

+ func (sk *SpikeParams) ActToISI(act, timeInc, integ float32) float32

+ func (sk *SpikeParams) AvgFmISI(avg *float32, isi float32)

+ func (sk *SpikeParams) Defaults()

+ func (sk *SpikeParams) Update()

+ type SynComParams struct

+ Delay int

+ PFail float32

+ PFailWtMax float32

+ func (sc *SynComParams) Defaults()

+ func (sc *SynComParams) Fail(wt *float32)

+ func (sc *SynComParams) Update()

+ func (sc *SynComParams) WtFail(wt float32) bool

+ func (sc *SynComParams) WtFailP(wt float32) float32

+ type Synapse struct

+ DWt float32

+ LWt float32

+ Moment float32

+ Norm float32

+ Scale float32

+ Wt float32

+ func (sy *Synapse) SetVarByIndex(idx int, val float32)

+ func (sy *Synapse) SetVarByName(varNm string, val float32) error

+ func (sy *Synapse) VarByIndex(idx int) float32

+ func (sy *Synapse) VarByName(varNm string) (float32, error)

+ func (sy *Synapse) VarNames() []string

+ type Time struct

+ CycPerQtr int

+ Cycle int

+ CycleTot int

+ PlusPhase bool

+ Quarter int

+ Time float32

+ TimePerCyc float32

+ func NewTime() *Time

+ func (tm *Time) AlphaCycStart()

+ func (tm *Time) CycleInc()

+ func (tm *Time) Defaults()

+ func (tm *Time) QuarterCycle() int

+ func (tm *Time) QuarterInc()

+ func (tm *Time) Reset()

+ type TimeScales int32

+ const AlphaCycle

+ const BetaCycle

+ const Block

+ const Condition

+ const Cycle

+ const Episode

+ const Epoch

+ const Event

+ const Expt

+ const FastSpike

+ const Phase

+ const Quarter

+ const Run

+ const Scene

+ const Sequence

+ const ThetaCycle

+ const Tick

+ const TimeScalesN

+ const Trial

+ func (ev *TimeScales) UnmarshalJSON(b []byte) error

+ func (ev TimeScales) MarshalJSON() ([]byte, error)

+ func (i *TimeScales) FromString(s string) error

+ func (i TimeScales) String() string

+ type WtBalParams struct

+ AvgThr float32

+ HiGain float32

+ HiThr float32

+ LoGain float32

+ LoThr float32

+ On bool

+ func (wb *WtBalParams) Defaults()

+ func (wb *WtBalParams) Update()

+ func (wb *WtBalParams) WtBal(wbAvg float32) (fact, inc, dec float32)

+ type WtBalRecvPrjn struct

+ Avg float32

+ Dec float32

+ Fact float32

+ Inc float32

+ func (wb *WtBalRecvPrjn) Init()

+ type WtInitParams struct

+ Sym bool

+ func (wp *WtInitParams) Defaults()

+ type WtScaleParams struct

+ Abs float32

+ Rel float32

+ func (ws *WtScaleParams) Defaults()

+ func (ws *WtScaleParams) FullScale(savg, snu, ncon float32) float32

+ func (ws *WtScaleParams) SLayActScale(savg, snu, ncon float32) float32

+ func (ws *WtScaleParams) Update()

+ type WtSigParams struct

+ Gain float32

+ Off float32

+ SoftBound bool

+ func (ws *WtSigParams) Defaults()

+ func (ws *WtSigParams) LinFmSigWt(sw float32) float32

+ func (ws *WtSigParams) SigFmLinWt(lw float32) float32

+ func (ws *WtSigParams) Update()

+ type XCalParams struct

+ DRev float32

+ DRevRatio float32

+ DThr float32

+ LLrn float32

+ LrnThr float32

+ MLrn float32

+ SetLLrn bool

+ func (xc *XCalParams) DWt(srval, thrP float32) float32

+ func (xc *XCalParams) Defaults()

+ func (xc *XCalParams) LongLrate(avgLLrn float32) float32

+ func (xc *XCalParams) Update()