leabra

package

Go to main page

Versions in this module

v1

v1.1.31

Mar 19, 2021

v1.1.28

Jan 13, 2021

v1.1.27

Jan 12, 2021

Changes in this version

type Layer

+ func (ly *Layer) WtFail()

+ func (ly *Layer) WtFmLWt()

type LeabraLayer

+ WtFail func()

+ WtFmLWt func()

type LeabraPrjn

+ WtFail func()

+ WtFmLWt func()

type LearnSynParams

+ func (ls *LearnSynParams) WtFail(wt *float32)

type Network

+ func (nt *Network) WtFail()

+ func (nt *Network) WtFmLWt()

type Prjn

+ func (pj *Prjn) WtFail()

+ func (pj *Prjn) WtFmLWt()

v1.1.26

Jan 4, 2021

Changes in this version

+ const GitCommit

+ const Version

+ const VersionDate

+ var KiT_Prjn = kit.Types.AddType(&Prjn{}, PrjnProps)

+ var NeuronVarProps = map[string]string

+ var PrjnProps = ki.Props

+ var SynapseVarProps = map[string]string

+ func NeuronVarIdxByName(varNm string) (int, error)

+ func SynapseVarByName(varNm string) (int, error)

type ActParams

+ KNa knadapt.Params

+ func (ac *ActParams) GeFmRaw(nrn *Neuron, geRaw float32)

+ func (ac *ActParams) GeThrFmGnoK(nrn *Neuron) float32

+ func (ac *ActParams) GiFmRaw(nrn *Neuron, giRaw float32)

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

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

type Layer

+ 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) CostEst() (neur, syn, tot int)

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

+ func (ly *Layer) DecayStatePool(pool int, decay float32)

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

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

+ func (ly *Layer) IsTarget() bool

+ func (ly *Layer) LrateMult(mult float32)

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

+ 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) SetWts(lw *weights.Layer) error

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

+ func (ly *Layer) UnitVarNum() int

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

+ func (ly *Layer) UpdateExtFlags()

type LayerStru

+ Network emer.Network

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

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

type LeabraLayer

+ CyclePost func(ltime *Time)

+ IsTarget func() bool

+ LrateMult func(mult float32)

+ UpdateExtFlags func()

+ type LeabraNetwork interface

+ AlphaCycInitImpl func()

+ AsLeabra func() *Network

+ CycleImpl func(ltime *Time)

+ CyclePostImpl func(ltime *Time)

+ DWtImpl func()

+ QuarterFinalImpl func(ltime *Time)

+ WtFmDWtImpl func()

type LeabraPrjn

+ LrateMult func(mult float32)

type LearnSynParams

+ LrateInit float32

+ func (ls *LearnSynParams) BCMdWt(suAvgSLrn, ruAvgSLrn, ruAvgL float32) float32

type Network

+ func (nt *Network) AlphaCycInitImpl()

+ func (nt *Network) AsLeabra() *Network

+ func (nt *Network) CollectDWts(dwts *[]float32, nwts int) bool

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

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

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

+ func (nt *Network) DWtImpl()

+ func (nt *Network) DecayState(decay float32)

+ func (nt *Network) GScaleFmAvgAct()

+ func (nt *Network) InitGInc()

+ func (nt *Network) InitTopoScales()

+ func (nt *Network) LayersSetOff(off bool)

+ func (nt *Network) LrateMult(mult float32)

+ func (nt *Network) QuarterFinalImpl(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) WtFmDWtImpl()

type NetworkStru

+ LockThreads bool

+ MetaData map[string]string

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

+ func (nt *NetworkStru) AllWtScales() string

+ 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) ConnectLayersPrjn(send, recv emer.Layer, pat prjn.Pattern, typ emer.PrjnType, pj emer.Prjn) emer.Prjn

+ 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) OpenWtsCpp(filename gi.FileName) error

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

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

type Neuron

+ ActLrn float32

+ ActQ0 float32

+ ActQ1 float32

+ ActQ2 float32

+ Gk float32

+ GknaFast float32

+ GknaMed float32

+ GknaSlow float32

+ ISI float32

+ ISIAvg float32

+ Spike float32

type Prjn

+ WtInit WtInitParams

+ func (pj *Prjn) InitWtsSyn(syn *Synapse)

+ func (pj *Prjn) LrateMult(mult float32)

+ 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) 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) SynVal1D(varIdx int, synIdx int) float32

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

+ func (pj *Prjn) SynVarNum() int

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

type PrjnStru

+ func (ps *PrjnStru) PrjnTypeName() string

type Quarters

+ func (qt *Quarters) Clear(qtr int)

+ func (qt *Quarters) Set(qtr int)

+ func (qt Quarters) Has(qtr int) bool

+ func (qt Quarters) HasNext(qtr int) bool

+ func (qt Quarters) HasPrev(qtr int) bool

type Synapse

+ Scale float32

+ func (sy *Synapse) SetVarByIndex(idx int, val float32)

+ func (sy *Synapse) VarByIndex(idx int) float32

type Time

+ func (tm *Time) QuarterCycle() int

type TimeScales

+ const Condition

+ const Tick

+ type WtInitParams struct

+ Sym bool

+ func (wp *WtInitParams) Defaults()

type WtSigParams

+ PFail float32

+ PFailWtMax float32

+ func (ws *WtSigParams) WtFail(wt float32) bool

+ func (ws *WtSigParams) WtFailP(wt float32) float32

v0

v0.5.0

Jun 12, 2019

Changes in this version

+ const NeuronVarStart

+ var KiT_ActNoiseType = kit.Enums.AddEnum(ActNoiseTypeN, false, nil)

+ var KiT_Layer = kit.Types.AddType(&Layer{}, LayerProps)

+ var KiT_Network = kit.Types.AddType(&Network{}, NetworkProps)

+ var KiT_NeurFlags = kit.Enums.AddEnum(NeurFlagsN, true, nil)

+ var KiT_Quarters = kit.Enums.AddEnum(QuartersN, true, nil)

+ var KiT_TimeScales = kit.Enums.AddEnum(TimeScalesN, false, nil)

+ var LayerProps = ki.Props

+ var NetworkProps = ki.Props

+ var NeuronVars = []string

+ var NeuronVarsMap map[string]int

+ var SynapseVars = []string

+ var SynapseVarsMap map[string]int

+ func JsonToParams(b []byte) string

+ func NeuronVarByName(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

+ 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

+ 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

+ ErevSubThr Chans

+ Gbar Chans

+ Init ActInitParams

+ Noise ActNoiseParams

+ OptThresh OptThreshParams

+ ThrSubErev Chans

+ VmRange minmax.F32

+ XX1 XX1Params

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

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

+ func (ac *ActParams) Defaults()

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

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

+ func (ac *ActParams) GeThrFmG(nrn *Neuron) 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) InitActs(nrn *Neuron)

+ func (ac *ActParams) InitGeGi(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 Chans struct

+ E float32

+ I float32

+ K float32

+ L float32

+ func (ch *Chans) SetAll(e, l, i, k float32)

+ func (ch *Chans) SetFmMinusOther(minus float32, oth Chans)

+ func (ch *Chans) SetFmOtherMinus(oth Chans, minus float32)

+ type ClampParams struct

+ Avg bool

+ AvgGain float32

+ Gain float32

+ Hard bool

+ Range minmax.F32

+ 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

+ GDt float32

+ GTau float32

+ Integ float32

+ VmDt float32

+ VmTau float32

+ func (dp *DtParams) Defaults()

+ func (dp *DtParams) GFmRaw(geRaw float32, ge *float32)

+ func (dp *DtParams) Update()

+ type FFFBInhib struct

+ FBi float32

+ FFi float32

+ Gi float32

+ GiOrig float32

+ LayGi float32

+ func (fi *FFFBInhib) Init()

+ type FFFBParams struct

+ FB float32

+ FBDt float32

+ FBTau float32

+ FF float32

+ FF0 float32

+ Gi float32

+ MaxVsAvg float32

+ On bool

+ func (fb *FFFBParams) Defaults()

+ func (fb *FFFBParams) FBInhib(avgAct float32) float32

+ func (fb *FFFBParams) FBUpdt(fbi *float32, newFbi float32)

+ func (fb *FFFBParams) FFInhib(avgGe, maxGe float32) float32

+ func (fb *FFFBParams) Inhib(avgGe, maxGe, avgAct float32, inh *FFFBInhib)

+ func (fb *FFFBParams) Update()

+ type InhibParams struct

+ ActAvg ActAvgParams

+ Layer FFFBParams

+ Pool FFFBParams

+ Self SelfInhibParams

+ func (ip *InhibParams) Defaults()

+ func (ip *InhibParams) Update()

+ type LayFunChan chan func(ly LeabraLayer)

+ 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) ApplyExtFlags() (clrmsk, setmsk int32, toTarg bool)

+ func (ly *Layer) AsLeabra() *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) DWt()

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

+ func (ly *Layer) Defaults()

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

+ func (ly *Layer) GScaleFmAvgAct()

+ func (ly *Layer) GenNoise()

+ func (ly *Layer) HardClamp()

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

+ func (ly *Layer) InitActAvg()

+ func (ly *Layer) InitActs()

+ func (ly *Layer) InitExt()

+ func (ly *Layer) InitGInc()

+ func (ly *Layer) InitWtSym()

+ func (ly *Layer) InitWts()

+ func (ly *Layer) LesionNeurons(prop float32) int

+ func (ly *Layer) MSE(tol float32) (sse, mse float64)

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

+ 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) SSE(tol float32) float64

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

+ func (ly *Layer) UnLesionNeurons()

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

+ func (ly *Layer) UnitVal1D(varNm string, idx int) float32

+ func (ly *Layer) UnitVal1DTry(varNm string, idx int) (float32, error)

+ func (ly *Layer) UnitValTry(varNm string, idx []int) (float32, error)

+ func (ly *Layer) UnitVals(varNm string) []float32

+ func (ly *Layer) UnitValsTensor(varNm string) etensor.Tensor

+ func (ly *Layer) UnitValsTensorTry(varNm string) (etensor.Tensor, error)

+ func (ly *Layer) UnitValsTry(varNm string) ([]float32, error)

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

+ 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

+ Cls string

+ Idx int

+ LeabraLay LeabraLayer

+ 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) Index() int

+ func (ls *LayerStru) InitName(lay emer.Layer, name string)

+ 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) 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 LeabraLayer interface

+ ActFmG func(ltime *Time)

+ AlphaCycInit func()

+ ApplyExt func(ext etensor.Tensor)

+ ApplyExt1D func(ext []float64)

+ AsLeabra func() *Layer

+ AvgLFmAvgM func()

+ AvgMaxAct func(ltime *Time)

+ AvgMaxGe func(ltime *Time)

+ CosDiffFmActs func()

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

+ InitGInc func()

+ InitWtSym func()

+ InitWts func()

+ QuarterFinal func(ltime *Time)

+ SendGDelta func(ltime *Time)

+ WtBalFmWt func()

+ WtFmDWt func()

+ type LeabraPrjn interface

+ AsLeabra func() *Prjn

+ DWt func()

+ InitGInc func()

+ InitWtSym func(rpj LeabraPrjn)

+ InitWts func()

+ RecvGInc func()

+ SendGDelta func(si int, delta float32)

+ WtBalFmWt func()

+ WtFmDWt func()

+ 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

+ Momentum MomentumParams

+ Norm DWtNormParams

+ WtBal WtBalParams

+ WtInit erand.RndParams

+ WtSig WtSigParams

+ XCal XCalParams

+ func (ls *LearnSynParams) CHLdWt(suAvgSLrn, suAvgM, ruAvgSLrn, ruAvgM, ruAvgL float32) (err, bcm float32)

+ func (ls *LearnSynParams) Defaults()

+ func (ls *LearnSynParams) InitWts(syn *Synapse)

+ func (ls *LearnSynParams) LWtFmWt(syn *Synapse)

+ func (ls *LearnSynParams) Update()

+ func (ls *LearnSynParams) WtFmDWt(wbInc, wbDec float32, dwt, wt, lwt *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

+ func (aa *LrnActAvgParams) AvgsFmAct(ruAct 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 Network struct

+ WtBalCtr int

+ WtBalInterval int

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

+ func (nt *Network) AlphaCycInit()

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

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

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

+ func (nt *Network) DWt()

+ func (nt *Network) Defaults()

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

+ func (nt *Network) InitActs()

+ func (nt *Network) InitExt()

+ func (nt *Network) InitWts()

+ func (nt *Network) NewLayer() emer.Layer

+ func (nt *Network) NewPrjn() emer.Prjn

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

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

+ func (nt *Network) UpdateParams()

+ func (nt *Network) WtBalFmWt()

+ func (nt *Network) WtFmDWt()

+ type NetworkStru struct

+ EmerNet emer.Network

+ FunTimes map[string]*timer.Time

+ LayMap map[string]emer.Layer

+ Layers emer.Layers

+ MaxPos mat32.Vec3

+ 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) AllParams() string

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

+ 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) 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) 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) OpenWtsJSON(filename gi.FileName) error

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

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

+ func (nt *NetworkStru) StartThreads()

+ func (nt *NetworkStru) StdVertLayout()

+ func (nt *NetworkStru) StopThreads()

+ func (nt *NetworkStru) ThrLayFun(fun func(ly LeabraLayer), 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)

+ 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

+ ActM float32

+ ActP float32

+ ActSent float32

+ AvgL float32

+ AvgLLrn float32

+ AvgM float32

+ AvgS float32

+ AvgSLrn float32

+ AvgSS float32

+ Ext float32

+ Flags NeurFlags

+ Ge float32

+ GeInc float32

+ GeRaw float32

+ Gi float32

+ GiInc float32

+ GiRaw float32

+ GiSelf float32

+ GiSyn float32

+ Inet float32

+ Noise float32

+ SubPool int32

+ Targ float32

+ Vm 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 OptThreshParams struct

+ Delta float32

+ Send float32

+ func (ot *OptThreshParams) Defaults()

+ func (ot *OptThreshParams) Update()

+ type Pool struct

+ Act minmax.AvgMax32

+ ActAvg ActAvg

+ ActM minmax.AvgMax32

+ ActP minmax.AvgMax32

+ EdIdx int

+ Ge minmax.AvgMax32

+ Inhib FFFBInhib

+ StIdx int

+ func (pl *Pool) Init()

+ type Prjn struct

+ GInc []float32

+ GScale float32

+ Learn LearnSynParams

+ Syns []Synapse

+ WbRecv []WtBalRecvPrjn

+ WtScale WtScaleParams

+ func (pj *Prjn) AllParams() string

+ func (pj *Prjn) AsLeabra() *Prjn

+ func (pj *Prjn) Build() error

+ func (pj *Prjn) DWt()

+ func (pj *Prjn) Defaults()

+ func (pj *Prjn) InitGInc()

+ func (pj *Prjn) InitWtSym(rpjp LeabraPrjn)

+ func (pj *Prjn) InitWts()

+ func (pj *Prjn) ReadWtsJSON(r io.Reader) error

+ func (pj *Prjn) RecvGInc()

+ func (pj *Prjn) SendGDelta(si int, delta float32)

+ func (pj *Prjn) SetSynVal(varnm string, sidx, ridx int, val float32) error

+ func (pj *Prjn) SynVal(varnm string, sidx, ridx int) float32

+ func (pj *Prjn) SynValTry(varnm string, sidx, ridx int) (float32, error)

+ func (pj *Prjn) SynVals(varnm string) []float32

+ func (pj *Prjn) SynValsTry(varnm string) ([]float32, error)

+ func (pj *Prjn) SynVarNames() []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

+ Cls string

+ LeabraPrj LeabraPrjn

+ 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) RecvLay() emer.Layer

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

+ func (ps *PrjnStru) SetClass(cls string)

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

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

+ func (ps *PrjnStru) SetType(typ emer.PrjnType)

+ func (ps *PrjnStru) String() string

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

+ func (ps *PrjnStru) TypeName() string

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

+ type Quarters int32

+ const Q1

+ const Q2

+ const Q3

+ const Q4

+ const QuartersN

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

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

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

+ func (i Quarters) String() string

+ 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 Synapse struct

+ DWt float32

+ LWt float32

+ Moment float32

+ Norm float32

+ Wt float32

+ func (sy *Synapse) SetVarByName(varNm string, val float64) bool

+ func (sy *Synapse) VarByName(varNm string) (float32, bool)

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

+ func (tm *Time) Reset()

+ type TimeScales int32

+ const AlphaCycle

+ const BetaCycle

+ const Block

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

+ type XX1Params struct

+ Gain float32

+ GainCor float32

+ GainCorRange float32

+ InterpRange float32

+ InterpVal float32

+ NVar float32

+ SigGain float32

+ SigGainNVar float32

+ SigMult float32

+ SigMultEff float32

+ SigMultPow float32

+ SigValAt0 float32

+ Thr float32

+ VmActThr float32

+ func (xp *XX1Params) Defaults()

+ func (xp *XX1Params) NoisyXX1(x float32) float32

+ func (xp *XX1Params) NoisyXX1Gain(x, gain float32) float32

+ func (xp *XX1Params) Update()

+ func (xp *XX1Params) XX1(x float32) float32

+ func (xp *XX1Params) XX1GainCor(x float32) float32

+ func (xp *XX1Params) XX1GainCorGain(x, gain float32) float32

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL