コード例 #1
0
    def ConfigTstTrlLog(ss, dt):
        dt.SetMetaData("name", "TstTrlLog")
        dt.SetMetaData("desc", "Record of testing per input pattern")
        dt.SetMetaData("read-only", "true")
        dt.SetMetaData("precision", str(LogPrec))

        nt = ss.TestEnv.Table.Len()
        sch = etable.Schema(
            [etable.Column("Trial", etensor.INT64, go.nil, go.nil),
            etable.Column("TrialName", etensor.STRING, go.nil, go.nil),
            etable.Column("Cycle", etensor.INT64, go.nil, go.nil)]
        )
        for lnm in ss.TstRecLays:
            ly = leabra.Layer(ss.Net.LayerByName(lnm))
            sch.append( etable.Column(lnm, etensor.FLOAT64, ly.Shp.Shp, go.nil))
        dt.SetFromSchema(sch, nt)
コード例 #2
0
    def ApplyInputs(ss, en):
        """
        ApplyInputs applies input patterns from given envirbonment.
        It is good practice to have this be a separate method with appropriate
        args so that it can be used for various different contexts
        (training, testing, etc).
        """
        ss.Net.InitExt()

        # going to the same layers, but good practice and cheap anyway
        lays = ["LGNon", "LGNoff"]
        for lnm in lays:
            ly = leabra.Layer(ss.Net.LayerByName(lnm))
            pats = en.State(ly.Nm)
            if pats != 0:
                ly.ApplyExt(pats)
コード例 #3
0
    def LogTrnEpc(ss, dt):
        """
        LogTrnEpc adds data from current epoch to the TrnEpcLog table.
        computes epoch averages prior to logging.

        # this is triggered by increment so use previous value
        """
        row = dt.Rows
        dt.SetNumRows(row + 1)

        epc = ss.TrainEnv.Epoch.Prv
        nt = float(ss.TrainEnv.Table.Len()) # number of trials in view

        ss.EpcSSE = ss.SumSSE / nt
        ss.SumSSE = 0
        ss.EpcAvgSSE = ss.SumAvgSSE / nt
        ss.SumAvgSSE = 0
        ss.EpcPctErr = float(ss.SumErr) / nt
        ss.SumErr = 0
        ss.EpcPctCor = 1 - ss.EpcPctErr
        ss.EpcCosDiff = ss.SumCosDiff / nt
        ss.SumCosDiff = 0
        if ss.FirstZero < 0 and ss.EpcPctErr == 0:
            ss.FirstZero = epc
        if ss.EpcPctErr == 0:
            ss.NZero += 1
        else:
            ss.NZero = 0

        dt.SetCellFloat("Run", row, float(ss.TrainEnv.Run.Cur))
        dt.SetCellFloat("Epoch", row, float(epc))
        dt.SetCellFloat("SSE", row, ss.EpcSSE)
        dt.SetCellFloat("AvgSSE", row, ss.EpcAvgSSE)
        dt.SetCellFloat("PctErr", row, ss.EpcPctErr)
        dt.SetCellFloat("PctCor", row, ss.EpcPctCor)
        dt.SetCellFloat("CosDiff", row, ss.EpcCosDiff)

        for lnm in ss.LayStatNms:
            ly = leabra.Layer(ss.Net.LayerByName(lnm))
            dt.SetCellFloat(ly.Nm+" ActAvg", row, float(ly.Pool(0).ActAvg.ActPAvgEff))

        # note: essential to use Go version of update when called from another goroutine
        ss.TrnEpcPlot.GoUpdate()
        if ss.TrnEpcFile != 0:
            if ss.TrainEnv.Run.Cur == 0 and epc == 0:
                dt.WriteCSVHeaders(ss.TrnEpcFile, etable.Tab)
            dt.WriteCSVRow(ss.TrnEpcFile, row, etable.Tab)
コード例 #4
0
 def Harmony(ss, nt):
     """
     Harmony computes the harmony (excitatory net input Ge * Act)
     """
     harm = float(0)
     nu = 0
     for lyi in nt.Layers:
         ly = leabra.Layer(handle=lyi)
         if ly.IsOff():
             continue
         for nrni in ly.Neurons:
             nrn = leabra.Neuron(handle=nrni)
             harm += nrn.Ge * nrn.Act
             nu += 1
     if nu > 0:
         harm /= float(nu)
     return harm
コード例 #5
0
    def ApplyInputs(ss, en):
        """
        ApplyInputs applies input patterns from given envirbonment.
        It is good practice to have this be a separate method with appropriate

        # going to the same layers, but good practice and cheap anyway
        args so that it can be used for various different contexts
        (training, testing, etc).
        """
        ss.Net.InitExt()

        lays = go.Slice_string(["Name", "Identity", "Color", "FavoriteFood", "Size", "Species", "FavoriteToy"])
        for lnm in lays :
            ly = leabra.Layer(ss.Net.LayerByName(lnm))
            pats = en.State(ly.Nm)
            if pats != 0:
                ly.ApplyExt(pats)
コード例 #6
0
    def TrainTrial(ss):
        """
        TrainTrial runs one trial of training using TrainEnv
        """
        if ss.NeedsNewRun:
            ss.NewRun()

        ss.TrainEnv.Step()

        # Key to query counters FIRST because current state is in NEXT epoch
        # if epoch counter has changed
        epc = env.CounterCur(ss.TrainEnv, env.Epoch)
        chg = env.CounterChg(ss.TrainEnv, env.Epoch)
        if chg:
            if ss.ViewOn and ss.TrainUpdt.value > leabra.AlphaCycle:
                ss.UpdateView(True)
            if epc >= ss.MaxEpcs:
                # done with training..
                ss.RunEnd()
                if ss.TrainEnv.Run.Incr():  # we are done!
                    ss.StopNow = True
                    return
                else:
                    ss.NeedsNewRun = True
                    return

        rch = leabra.Layer(ss.Net.LayerByName("Reach"))
        if "choice" in ss.TrainEnv.TrialName.Cur:
            rch.SetType(emer.Compare)
        else:
            rch.SetType(emer.Input)

        if ss.TrainEnv.GroupName.Cur != ss.PrvGpName:  # init at start of new group
            ss.Net.InitActs()
            ss.PrvGpName = ss.TrainEnv.GroupName.Cur
        train = True
        if "delay" in ss.TrainEnv.TrialName.Cur:
            train = False  # don't learn on delay trials

        ss.ApplyInputs(ss.TrainEnv)
        ss.AlphaCyc(train)
        ss.TrialStats(True)  # accumulate
        ss.LogTrnTrl(ss.TrnTrlLog, ss.TrainEnv.Trial.Cur,
                     ss.TrainEnv.TrialName.Cur)
コード例 #7
0
ファイル: attn.py プロジェクト: mewbak/axon
    def AlphaCyc(ss):
        """
        AlphaCyc runs one alpha-cycle (100 msec, 4 quarters) of processing.
        External inputs must have already been applied prior to calling,
        using ApplyExt method on relevant layers (see TrainTrial, TestTrial).
        Handles netview updating within scope of AlphaCycle
        """

        if ss.Win != 0:
            ss.Win.PollEvents(
            )  # this is essential for GUI responsiveness while running
        viewUpdt = ss.ViewUpdt.value

        out = leabra.Layer(ss.Net.LayerByName("Output"))

        ss.Net.AlphaCycInit()
        ss.Time.AlphaCycStart()
        overThresh = False
        for qtr in range(4):
            for cyc in range(ss.Time.CycPerQtr):
                ss.Net.Cycle(ss.Time)
                ss.Time.CycleInc()
                if viewUpdt == leabra.Cycle:
                    if cyc != ss.Time.CycPerQtr - 1:  # will be updated by quarter
                        ss.UpdateView()
                if viewUpdt == leabra.FastSpike:
                    if (cyc + 1) % 10 == 0:
                        ss.UpdateView()
                trgact = out.Neurons[1].Act
                if trgact > 0.5:
                    overThresh = True
                    break
            ss.Net.QuarterFinal(ss.Time)
            ss.Time.QuarterInc()
            if viewUpdt <= leabra.Quarter:
                ss.UpdateView()
            if viewUpdt == leabra.Phase:
                if qtr >= 2:
                    ss.UpdateView()
            if overThresh:
                break

        ss.UpdateView()
コード例 #8
0
    def ConfigTrnTrlLog(ss, dt):
        dt.SetMetaData("name", "TrnTrlLog")
        dt.SetMetaData("desc", "Record of training per input event (time step)")
        dt.SetMetaData("read-only", "true")
        dt.SetMetaData("precision", str(LogPrec))

        nt = 0
        sch = etable.Schema(
            [etable.Column("Run", etensor.INT64, go.nil, go.nil),
            etable.Column("Epoch", etensor.INT64, go.nil, go.nil),
            etable.Column("Trial", etensor.INT64, go.nil, go.nil),
            etable.Column("Event", etensor.INT64, go.nil, go.nil),
            etable.Column("TD", etensor.FLOAT64, go.nil, go.nil),
            etable.Column("RewPred", etensor.FLOAT64, go.nil, go.nil)]
        )
        for lnm in ss.TstRecLays:
            ly = leabra.Layer(ss.Net.LayerByName(lnm))
            sch.append( etable.Column(lnm, etensor.FLOAT64, ly.Shp.Shp, go.nil))
        dt.SetFromSchema(sch, nt)
コード例 #9
0
 def SetParams(ss, sheet, setMsg):
     """
     SetParams sets the params for "Base" and then current ParamSet.
     If sheet is empty, then it applies all avail sheets (e.g., Network, Sim)
     otherwise just the named sheet
     if setMsg = true then we output a message for each param that was set.
     """
     if sheet == "":
         ss.Params.ValidateSheets(go.Slice_string(["Network", "Sim"]))
     ss.SetParamsSet("Base", sheet, setMsg)
     if ss.ParamSet != "" and ss.ParamSet != "Base":
         sps = ss.ParamSet.split()
         for ps in sps:
             ss.SetParamsSet(ps, sheet, setMsg)
     ly = leabra.Layer(ss.Net.LayerByName("NeckerCube"))
     ly.Act.Noise.Var = float(ss.Noise)
     ly.Act.KNa.On = ss.KNaAdapt
     ly.Act.Update()
     ss.Time.CycPerQtr = int(ss.CycPerQtr)
コード例 #10
0
    def LogTstTrl(ss, dt):
        """
        LogTstTrl adds data from current trial to the TstTrlLog table.
        log always contains number of testing items
        """
        trl = ss.TestEnv.Trial.Cur
        row = trl

        if dt.Rows <= row:
            dt.SetNumRows(row + 1)
        dt.SetCellFloat("Trial", row, float(trl))
        dt.SetCellString("TrialName", row, ss.TestEnv.TrialName.Cur)

        for lnm in ss.TstRecLays:
            tsr = ss.ValsTsr(lnm)
            ly = leabra.Layer(ss.Net.LayerByName(lnm))
            ly.UnitValsTensor(tsr, "Act")
            dt.SetCellTensor(lnm, row, tsr)

        ss.TstTrlPlot.GoUpdate()
コード例 #11
0
 def SetParamsSet(ss, setNm, sheet, setMsg):
     """
     SetParamsSet sets the params for given params.Set name.
     If sheet is empty, then it applies all avail sheets (e.g., Network, Sim)
     otherwise just the named sheet
     if setMsg = true then we output a message for each param that was set.
     """
     pset = ss.Params.SetByNameTry(setNm)
     if sheet == "" or sheet == "Network":
         if "Network" in pset.Sheets:
             netp = pset.SheetByNameTry("Network")
             ss.Net.ApplyParams(netp, setMsg)
         hid = leabra.Layer(ss.Net.LayerByName("Hidden"))
         fmhid = leabra.Prjn(hid.RcvPrjns.SendName("Hidden"))
         fmhid.WtInit.Mean = ss.RecurrentWt
     if sheet == "" or sheet == "Sim":
         if "Sim" in pset.Sheets:
             simp = pset.SheetByNameTry("Sim")
             pyparams.ApplyParams(ss, simp, setMsg)
             simp.Apply(ss, setMsg)
コード例 #12
0
ファイル: inhib.py プロジェクト: mewbak/axon
    def LogTstCyc(ss, dt, cyc):
        """
        LogTstCyc adds data from current cycle to the TstCycLog table.
        log always contains number of testing items
        """
        nt = ss.Net()
        if dt.Rows <= cyc:
            dt.SetNumRows(cyc + 1)
        row = cyc

        dt.SetCellFloat("Cycle", row, float(cyc))

        for lnm in ss.TstRecLays:
            ly = leabra.Layer(nt.LayerByName(lnm))
            dt.SetCellFloat(lnm + "ActAvg", row,
                            float(ly.Pool(0).Inhib.Act.Avg))

        # note: essential to use Go version of update when called from another goroutine
        if cyc % 10 == 0:
            ss.TstCycPlot.GoUpdate()
コード例 #13
0
 def SetParams(ss, sheet, setMsg):
     """
     SetParams sets the params for "Base" and then current ParamSet.
     If sheet is empty, then it applies all avail sheets (e.g., Network, Sim)
     otherwise just the named sheet
     if setMsg = true then we output a message for each param that was set.
     """
     if sheet == "":
         ss.Params.ValidateSheets(go.Slice_string(["Network", "Sim"]))
     ss.SetParamsSet("Base", sheet, setMsg)
     if ss.ParamSet != "" and ss.ParamSet != "Base":
         sps = ss.ParamSet.split()
         for ps in sps:
             ss.SetParamsSet(ps, sheet, setMsg)
     nt = ss.Net
     v1 = leabra.Layer(nt.LayerByName("V1"))
     elat = leabra.Prjn(v1.RcvPrjns[2])
     elat.WtScale.Rel = ss.ExcitLateralScale
     elat.Learn.Learn = ss.ExcitLateralLearn
     ilat = leabra.Prjn(v1.RcvPrjns[3])
     ilat.WtScale.Abs = ss.InhibLateralScale
コード例 #14
0
    def LogTstCyc(ss, dt, cyc):
        """
        LogTstCyc adds data from current cycle to the TstCycLog table.
        log always contains number of testing items
        """
        if dt.Rows <= cyc:
            dt.SetNumRows(cyc + 1)
        row = cyc

        harm = ss.Harmony(ss.Net)
        dt.SetCellFloat("Cycle", row, float(cyc))
        dt.SetCellString("TrialName", row, ss.TestEnv.TrialName.Cur)
        dt.SetCellFloat("Harmony", row, float(harm))

        for lnm in ss.TstRecLays:
            tsr = ss.ValsTsr(lnm)
            ly = leabra.Layer(ss.Net.LayerByName(lnm))
            ly.UnitValsTensor(tsr, "Act")
            dt.SetCellTensor(lnm, row, tsr)

        ss.TstCycPlot.GoUpdate()
コード例 #15
0
 def TrialStats(ss, accum):
     """
     TrialStats computes the trial-level statistics and adds them to the epoch accumulators if
     accum is true.  Note that we're accumulating stats here on the Sim side so the
     core algorithm side remains as simple as possible, and doesn't need to worry about
     different time-scales over which stats could be accumulated etc.
     You can also aggregate directly from log data, as is done for testing stats
     """
     out = leabra.Layer(ss.Net.LayerByName("Output"))
     ss.TrlCosDiff = float(out.CosDiff.Cos)
     ss.TrlSSE = out.SSE(0.5) # 0.5 = per-unit tolerance -- right side of .5
     ss.TrlAvgSSE = ss.TrlSSE / len(out.Neurons)
     if ss.TrlSSE > 0:
         ss.TrlErr = 1
     else:
         ss.TrlErr = 0
     if accum:
         ss.SumErr += ss.TrlErr
         ss.SumSSE += ss.TrlSSE
         ss.SumAvgSSE += ss.TrlAvgSSE
         ss.SumCosDiff += ss.TrlCosDiff
     return
コード例 #16
0
    def RunCycles(ss):
        """
        RunCycles updates neuron over specified number of cycles
        """
        ss.Init()
        ss.StopNow = False
        ss.Net.InitActs()
        ss.SetParams("", False)
        ly = leabra.Layer(ss.Net.LayerByName("Neuron"))
        nrn = ly.Neurons[0]
        inputOn = False
        for cyc in range(ss.NCycles):
            if ss.Win != 0:
                ss.Win.PollEvents(
                )  # this is essential for GUI responsiveness while running

            ss.Cycle = cyc
            if cyc == ss.OnCycle:
                inputOn = True
            if cyc == ss.OffCycle:
                inputOn = False
            nrn.Noise = float(ly.Act.Noise.Gen(-1))
            if inputOn:
                nrn.Ge = 1
            else:
                nrn.Ge = 0
            nrn.Ge += nrn.Noise  # GeNoise
            nrn.Gi = 0
            if ss.Spike:
                ss.SpikeUpdt(ss.Net, inputOn)
            else:
                ss.RateUpdt(ss.Net, inputOn)
            ss.LogTstCyc(ss.TstCycLog, ss.Cycle)
            if ss.Cycle % ss.UpdtInterval == 0:
                ss.UpdateView()
            if ss.StopNow:
                break
        ss.UpdateView()
コード例 #17
0
    def LogTstCyc(ss, dt, cyc):
        """
        LogTstCyc adds data from current cycle to the TstCycLog table.
        """
        if dt.Rows <= cyc:
            dt.SetNumRows(cyc + 1)
        row = cyc

        ly = leabra.Layer(ss.Net.LayerByName("Neuron"))
        nrn = leabra.Neuron(ly.Neurons[0])

        dt.SetCellFloat("Cycle", row, float(cyc))
        dt.SetCellFloat("Ge", row, float(nrn.Ge))
        dt.SetCellFloat("Inet", row, float(nrn.Inet))
        dt.SetCellFloat("Vm", row, float(nrn.Vm))
        dt.SetCellFloat("Act", row, float(nrn.Act))
        dt.SetCellFloat("Spike", row, float(nrn.Spike))
        dt.SetCellFloat("Gk", row, float(nrn.Gk))
        dt.SetCellFloat("ISI", row, float(nrn.ISI))
        dt.SetCellFloat("AvgISI", row, float(nrn.ISIAvg))

        # note: essential to use Go version of update when called from another goroutine
        if cyc % ss.UpdtInterval == 0:
            ss.TstCycPlot.GoUpdate()