def ConfigNetView(ss, nv):
nv.ViewDefaults()
nv.Scene().Camera.Pose.Pos.Set(
0, 1.5,
3.0) # more "head on" than default which is more "top down"
nv.Scene().Camera.LookAt(mat32.Vec3(0, 0, 0), mat32.Vec3(0, 1, 0))
labs = go.Slice_string([
" Morr Socks Sylv Garf Fuzz Rex Fido Spot Snoop Butch",
" black white brown orange", "bugs grass scraps shoe",
"small med large", "cat dog", "string feath bone shoe"
])
nv.ConfigLabels(labs)
lays = go.Slice_string([
"Name", "Color", "FavoriteFood", "Size", "Species", "FavoriteToy"
])
li = 0
for lnm in lays:
ly = nv.LayerByName(lnm)
lbl = nv.LabelByName(labs[li])
lbl.Pose = ly.Pose
lbl.Pose.Pos.Y += .2
lbl.Pose.Pos.Z += .02
lbl.Pose.Scale.SetMul(mat32.Vec3(0.4, 0.08, 0.5))
li += 1
def SetNStim(ev, n):
"""
SetNStim initializes env for given number of stimuli, init states
"""
ev.NStim = n
ev.Input.SetShape(go.Slice_int([Actions.ActionsN.value + n]), go.nil, go.Slice_string(["N"]))
ev.Output.SetShape(go.Slice_int([n]), go.nil, go.Slice_string(["N"]))
ev.Reward.SetShape(go.Slice_int([1]), go.nil, go.Slice_string(["1"]))
if ev.RewVal == 0:
ev.RewVal = 1
def SetN(ev, n):
"""
SetN initializes env for given number of options, and inits states
"""
ev.N = n
ev.P = [0.0] * n
ev.Input.SetShape(go.Slice_int([n]), go.nil, go.Slice_string(["N"]))
ev.Reward.SetShape(go.Slice_int([1]), go.nil, go.Slice_string(["1"]))
if ev.RewVal == 0:
ev.RewVal = 1
def ConfigPats(ss):
dt = ss.Pats
sch = etable.Schema(
[etable.Column("Name", etensor.STRING, go.nil, go.nil),
etable.Column("Input", etensor.FLOAT32, go.Slice_int([4, 5]), go.Slice_string(["Y", "X"])),
etable.Column("Output", etensor.FLOAT32, go.Slice_int([4, 5]), go.Slice_string(["Y", "X"]))]
)
dt.SetFromSchema(sch, 3)
ss.Pats.SetMetaData("name", "Pats")
ss.Pats.SetMetaData("desc", "Training patterns")
patgen.PermutedBinaryRows(dt.Cols[1], 6, 1, 0)
patgen.PermutedBinaryRows(dt.Cols[2], 6, 1, 0)
cn = etensor.String(dt.Cols[0])
cn.Values.copy(["any", "baker", "cheese"])
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"]))
spo = ss.Params.SetByName("Base").SheetByName("Network").SelByName(
".SpatToObj")
spo.Params.SetParamByName("Prjn.WtScale.Rel", ("%g" % (ss.SpatToObj)))
vsp = ss.Params.SetByName("Base").SheetByName("Network").SelByName(
"#V1ToSpat1")
vsp.Params.SetParamByName("Prjn.WtScale.Rel", ("%g" % (ss.V1ToSpat1)))
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)
if ss.KNaAdapt:
ss.SetParamsSet("KNaAdapt", sheet, setMsg)
def SetParams(ss, sheet, setMsg):
"""
SetParams sets the params for "Base" and then current ParamSet.
# this is important for catching typos and ensuring that all sheets can be used
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("Neuron"))
ly.Act.Gbar.E = float(ss.GbarE)
ly.Act.Gbar.L = float(ss.GbarL)
ly.Act.Erev.E = float(ss.ErevE)
ly.Act.Erev.L = float(ss.ErevL)
ly.Act.Noise.Var = float(ss.Noise)
ly.Act.KNa.On = ss.KNaAdapt
ly.Act.Update()
ss.SpikeParams.CopyFromAct(ly.Act) # keep sync'd
def Init(ev, run):
ev.Input.SetShape(go.Slice_int([3, ev.TotTime]), go.nil,
go.Slice_string(["3", "TotTime"]))
ev.Reward.SetShape(go.Slice_int([1]), go.nil, go.Slice_string(["1"]))
ev.Run.Scale = env.Run
ev.Epoch.Scale = env.Epoch
ev.Trial.Scale = env.Trial
ev.Event.Scale = env.Event
ev.Run.Init()
ev.Epoch.Init()
ev.Trial.Init()
ev.Event.Init()
ev.Run.Cur = run
ev.Event.Max = ev.TotTime
ev.Event.Cur = -1
ev.TrialUpdt()
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"]))
nt = ss.Net()
err = ss.SetParamsSet("Base", sheet, setMsg)
if ss.TrainedWts:
ss.SetParamsSet("Trained", sheet, setMsg)
else:
ss.SetParamsSet("Untrained", sheet, setMsg)
ffinhsc = ss.FFinhibWtScale
if nt == ss.NetBidir:
ffinhsc *= 0.5 # 2 inhib prjns so .5 ea
hid = leabra.LeabraLayer(nt.LayerByName("Hidden")).AsLeabra()
hid.Act.Gbar.I = ss.HiddenGbarI
hid.Act.Dt.GTau = ss.HiddenGTau
hid.Act.Update()
inh = leabra.LeabraLayer(nt.LayerByName("Inhib")).AsLeabra()
inh.Act.Gbar.I = ss.InhibGbarI
inh.Act.Dt.GTau = ss.InhibGTau
inh.Act.Update()
ff = leabra.LeabraPrjn(inh.RcvPrjns.SendName("Input")).AsLeabra()
ff.WtScale.Rel = ffinhsc
fb = leabra.LeabraPrjn(inh.RcvPrjns.SendName("Hidden")).AsLeabra()
fb.WtScale.Rel = ss.FBinhibWtScale
hid.Inhib.Layer.On = ss.FFFBInhib
inh.Inhib.Layer.On = ss.FFFBInhib
fi = leabra.LeabraPrjn(hid.RcvPrjns.SendName("Inhib")).AsLeabra()
fi.WtScale.Abs = ss.FmInhibWtScaleAbs
fi = leabra.LeabraPrjn(inh.RcvPrjns.SendName("Inhib")).AsLeabra()
fi.WtScale.Abs = ss.FmInhibWtScaleAbs
if nt == ss.NetBidir:
hid = leabra.LeabraLayer(nt.LayerByName("Hidden2")).AsLeabra()
hid.Act.Gbar.I = ss.HiddenGbarI
hid.Act.Dt.GTau = ss.HiddenGTau
hid.Act.Update()
inh = leabra.LeabraLayer(nt.LayerByName("Inhib2")).AsLeabra()
inh.Act.Gbar.I = ss.InhibGbarI
inh.Act.Dt.GTau = ss.InhibGTau
inh.Act.Update()
hid.Inhib.Layer.On = ss.FFFBInhib
inh.Inhib.Layer.On = ss.FFFBInhib
fi = leabra.LeabraPrjn(hid.RcvPrjns.SendName("Inhib2")).AsLeabra()
fi.WtScale.Abs = ss.FmInhibWtScaleAbs
fi = leabra.LeabraPrjn(inh.RcvPrjns.SendName("Inhib2")).AsLeabra()
fi.WtScale.Abs = ss.FmInhibWtScaleAbs
ff = leabra.LeabraPrjn(inh.RcvPrjns.SendName("Hidden")).AsLeabra()
ff.WtScale.Rel = ffinhsc
fb = leabra.LeabraPrjn(inh.RcvPrjns.SendName("Hidden2")).AsLeabra()
fb.WtScale.Rel = ss.FBinhibWtScale
inh = leabra.LeabraLayer(nt.LayerByName("Inhib")).AsLeabra()
ff = leabra.LeabraPrjn(inh.RcvPrjns.SendName("Hidden2")).AsLeabra()
ff.WtScale.Rel = ffinhsc
return err
def LogRun(ss, dt):
"""
LogRun adds data from current run to the RunLog table.
"""
run = ss.TrainEnv.Run.Cur # this is NOT triggered by increment yet -- use Cur
row = dt.Rows
dt.SetNumRows(row + 1)
epclog = ss.TrnEpcLog
epcix = etable.NewIdxView(epclog)
# compute mean over last N epochs for run level
nlast = 1
if nlast > epcix.Len()-1:
nlast = epcix.Len() - 1
epcix.Idxs = epcix.Idxs[epcix.Len()-nlast-1:]
params = "Std"
if ss.AvgLGain != 2.5:
params += "_AvgLGain=%s" % (ss.AvgLGain)
if ss.InputNoise != 0:
params += "_InVar=%s" % (ss.InputNoise)
dt.SetCellFloat("Run", row, float(run))
dt.SetCellString("Params", row, params)
dt.SetCellFloat("UniqPats", row, agg.Mean(epcix, "UniqPats")[0])
runix = etable.NewIdxView(dt)
spl = split.GroupBy(runix, go.Slice_string(["Params"]))
split.Desc(spl, "UniqPats")
ss.RunStats = spl.AggsToTable(etable.AddAggName)
# note: essential to use Go version of update when called from another goroutine
ss.RunPlot.GoUpdate()
def __init__(self):
super(ProbeEnv, self).__init__()
self.Nm = str()
self.SetTags("Nm", 'desc:"name of this environment"')
self.Dsc = str()
self.SetTags("Dsc", 'desc:"description of this environment"')
self.Words = go.Slice_string()
self.SetTags(
"Words",
'desc:"list of words used for activating state units according to index"'
)
self.WordState = etensor.Float32()
self.SetTags("WordState", 'desc:"current sentence activation state"')
self.Run = env.Ctr()
self.SetTags(
"Run",
'view:"inline" desc:"current run of model as provided during Init"'
)
self.Epoch = env.Ctr()
self.SetTags(
"Epoch",
'view:"inline" desc:"number of times through Seq.Max number of sequences"'
)
self.Trial = env.Ctr()
self.SetTags(
"Trial",
'view:"inline" desc:"trial is the step counter within sequence - how many steps taken within current sequence -- it resets to 0 at start of each sequence"'
)
def ScanWords(ev, txt):
ev.Words = go.Slice_string()
lns = txt.splitlines()
for ln in lns:
sp = ln.split()
for s in sp:
ev.Words.append(s)
ev.WordMapFmWords()
def __init__(self):
super(Sim, self).__init__()
self.SpatToObj = float(2)
self.SetTags("SpatToObj", 'def:"2" desc:"spatial to object projection WtScale.Rel strength -- reduce to 1.5, 1 to test"')
self.V1ToSpat1 = float(0.6)
self.SetTags("V1ToSpat1", 'def:"0.6" desc:"V1 to Spat1 projection WtScale.Rel strength -- reduce to .55, .5 to test"')
self.KNaAdapt = False
self.SetTags("KNaAdapt", 'def:"false" desc:"sodium (Na) gated potassium (K) channels that cause neurons to fatigue over time"')
self.CueDur = int(100)
self.SetTags("CueDur", 'def:"100" desc:"number of cycles to present the cue -- 100 by default, 50 to 300 for KNa adapt testing"')
self.Net = leabra.Network()
self.SetTags("Net", 'view:"no-inline" desc:"the network -- click to view / edit parameters for layers, prjns, etc"')
self.Test = TestType.MultiObjs
self.SetTags("Test", 'desc:"select which type of test (input patterns) to use"')
self.MultiObjs = etable.Table()
self.SetTags("MultiObjs", 'view:"no-inline" desc:"click to see these testing input patterns"')
self.StdPosner = etable.Table()
self.SetTags("StdPosner", 'view:"no-inline" desc:"click to see these testing input patterns"')
self.ClosePosner = etable.Table()
self.SetTags("ClosePosner", 'view:"no-inline" desc:"click to see these testing input patterns"')
self.ReversePosner = etable.Table()
self.SetTags("ReversePosner", 'view:"no-inline" desc:"click to see these testing input patterns"')
self.ObjAttn = etable.Table()
self.SetTags("ObjAttn", 'view:"no-inline" desc:"click to see these testing input patterns"')
self.TstTrlLog = etable.Table()
self.SetTags("TstTrlLog", 'view:"no-inline" desc:"testing trial-level log data -- click to see record of network\'s response to each input"')
self.TstStats = etable.Table()
self.SetTags("TstStats", 'view:"no-inline" desc:"aggregate stats on testing data"')
self.Params = params.Sets()
self.SetTags("Params", 'view:"no-inline" desc:"full collection of param sets -- not really interesting for this model"')
self.ParamSet = str()
self.SetTags("ParamSet", 'view:"-" desc:"which set of *additional* parameters to use -- always applies Base and optionaly this next if set -- can use multiple names separated by spaces (don\'t put spaces in ParamSet names!)"')
self.TestEnv = env.FixedTable()
self.SetTags("TestEnv", 'desc:"Testing environment -- manages iterating over testing"')
self.Time = leabra.Time()
self.SetTags("Time", 'desc:"leabra timing parameters and state"')
self.ViewUpdt = leabra.TimeScales.FastSpike
self.SetTags("ViewUpdt", 'desc:"at what time scale to update the display during testing? Change to AlphaCyc to make display updating go faster"')
self.TstRecLays = go.Slice_string(["Input", "V1", "Spat1", "Spat2", "Obj1", "Obj2", "Output"])
self.SetTags("TstRecLays", 'desc:"names of layers to record activations etc of during testing"')
# internal state - view:"-"
self.Win = 0
self.SetTags("Win", 'view:"-" desc:"main GUI window"')
self.NetView = 0
self.SetTags("NetView", 'view:"-" desc:"the network viewer"')
self.ToolBar = 0
self.SetTags("ToolBar", 'view:"-" desc:"the master toolbar"')
self.TstTrlPlot = 0
self.SetTags("TstTrlPlot", 'view:"-" desc:"the test-trial plot"')
self.ValsTsrs = {}
self.SetTags("ValsTsrs", 'view:"-" desc:"for holding layer values"')
self.IsRunning = False
self.SetTags("IsRunning", 'view:"-" desc:"true if sim is running"')
self.StopNow = False
self.SetTags("StopNow", 'view:"-" desc:"flag to stop running"')
self.vp = 0
self.SetTags("vp", 'view:"-" desc:"viewport"')
def ConfigGui(ss):
"""
ConfigGui configures the GoGi gui interface for this simulation,
"""
width = 1600
height = 1200
gi.SetAppName("pyet")
gi.SetAppAbout('testing of converting etable data between Go and Python. See <a href="https://github.com/emer/etable/blob/master/examples/pyet/README.md">README.md on GitHub</a>.</p>')
win = gi.NewMainWindow("pyet", "PyEt Testing", width, height)
ss.Win = win
vp = win.WinViewport2D()
ss.vp = vp
updt = vp.UpdateStart()
mfr = win.SetMainFrame()
tbar = gi.AddNewToolBar(mfr, "tbar")
tbar.SetStretchMaxWidth()
ss.ToolBar = tbar
split = gi.AddNewSplitView(mfr, "split")
split.Dim = mat32.X
split.SetStretchMax()
cv = ss.NewClassView("sv")
cv.AddFrame(split)
cv.Config()
tv = gi.AddNewTabView(split, "tv")
tabv = etview.TableView()
tv.AddTab(tabv, "Pats")
tabv.SetTable(ss.Pats, go.nil)
ss.PatsTable = tabv
split.SetSplitsList(go.Slice_float32([.2, .8]))
recv = win.This()
tbar.AddAction(gi.ActOpts(Label="Test", Icon="update", Tooltip="run the test."), recv, TestCB)
# main menu
appnm = gi.AppName()
mmen = win.MainMenu
mmen.ConfigMenus(go.Slice_string([appnm, "File", "Edit", "Window"]))
amen = gi.Action(win.MainMenu.ChildByName(appnm, 0))
amen.Menu.AddAppMenu(win)
emen = gi.Action(win.MainMenu.ChildByName("Edit", 1))
emen.Menu.AddCopyCutPaste(win)
win.MainMenuUpdated()
vp.UpdateEndNoSig(updt)
win.GoStartEventLoop()
def ItemsFromEnum(cb, enm):
nms = []
typ = type(enm)
nnm = typ.__name__ + "N" # common convention of using the type name + N for last item in list
for en in typ:
if en.name != nnm:
nms.append(en.name)
cb.ItemsFromStringList(go.Slice_string(nms), False, 0)
cb.SetCurVal(enm.name)
def WordsFmWordMap(ev):
ev.Words = go.Slice_string()
ctr = 0
for wrd in ev.WordMap:
ev.Words.append(wrd)
ctr += 1
ev.Words.sort()
for i, wrd in enumerate(ev.Words):
ev.WordMap[wrd] = i
def __init__(self):
super(Sim, self).__init__()
self.Net = leabra.Network()
self.SetTags("Net", 'view:"no-inline" desc:"the network -- click to view / edit parameters for layers, prjns, etc"')
self.Pats = etable.Table()
self.SetTags("Pats", 'view:"no-inline" desc:"click to see the full face testing input patterns to use"')
self.PartPats = etable.Table()
self.SetTags("PartPats", 'view:"no-inline" desc:"click to see the partial face testing input patterns to use"')
self.TstTrlLog = etable.Table()
self.SetTags("TstTrlLog", 'view:"no-inline" desc:"testing trial-level log data -- click to see record of network\'s response to each input"')
self.PrjnTable = etable.Table()
self.SetTags("PrjnTable", 'view:"no-inline" desc:"projection of testing data"')
self.Params = params.Sets()
self.SetTags("Params", 'view:"no-inline" desc:"full collection of param sets -- not really interesting for this model"')
self.ParamSet = str()
self.SetTags("ParamSet", 'view:"-" desc:"which set of *additional* parameters to use -- always applies Base and optionaly this next if set -- can use multiple names separated by spaces (don\'t put spaces in ParamSet names!)"')
self.TestEnv = env.FixedTable()
self.SetTags("TestEnv", 'desc:"Testing environment -- manages iterating over testing"')
self.Time = leabra.Time()
self.SetTags("Time", 'desc:"leabra timing parameters and state"')
self.ViewUpdt = leabra.TimeScales.Cycle
self.SetTags("ViewUpdt", 'desc:"at what time scale to update the display during testing? Change to AlphaCyc to make display updating go faster"')
self.TstRecLays = go.Slice_string(["Input", "Emotion", "Gender", "Identity"])
self.SetTags("TstRecLays", 'desc:"names of layers to record activations etc of during testing"')
self.ClustFaces = eplot.Plot2D()
self.SetTags("ClustFaces", 'view:"no-inline" desc:"cluster plot of faces"')
self.ClustEmote = eplot.Plot2D()
self.SetTags("ClustEmote", 'view:"no-inline" desc:"cluster plot of emotions"')
self.ClustGend = eplot.Plot2D()
self.SetTags("ClustGend", 'view:"no-inline" desc:"cluster plot of genders"')
self.ClustIdent = eplot.Plot2D()
self.SetTags("ClustIdent", 'view:"no-inline" desc:"cluster plot of identity"')
self.PrjnRandom = eplot.Plot2D()
self.SetTags("PrjnRandom", 'view:"no-inline" desc:"random projection plot"')
self.PrjnEmoteGend = eplot.Plot2D()
self.SetTags("PrjnEmoteGend", 'view:"no-inline" desc:"projection plot of emotions & gender"')
# internal state - view:"-"
self.Win = 0
self.SetTags("Win", 'view:"-" desc:"main GUI window"')
self.NetView = 0
self.SetTags("NetView", 'view:"-" desc:"the network viewer"')
self.ToolBar = 0
self.SetTags("ToolBar", 'view:"-" desc:"the master toolbar"')
self.TstTrlPlot = 0
self.SetTags("TstTrlPlot", 'view:"-" desc:"the test-trial plot"')
self.ValsTsrs = {}
self.SetTags("ValsTsrs", 'view:"-" desc:"for holding layer values"')
self.IsRunning = False
self.SetTags("IsRunning", 'view:"-" desc:"true if sim is running"')
self.StopNow = False
self.SetTags("StopNow", 'view:"-" desc:"flag to stop running"')
self.vp = 0
self.SetTags("vp", 'view:"-" desc:"viewport"')
def ConfigPats(ss):
dt = ss.Pats
dt.SetMetaData("name", "TrainPats")
dt.SetMetaData("desc", "Training patterns")
sch = etable.Schema([
etable.Column("Name", etensor.STRING, go.nil, go.nil),
etable.Column("Input", etensor.FLOAT32, go.Slice_int([10, 10]),
go.Slice_string(["Y", "X"]))
])
dt.SetFromSchema(sch, 1)
patgen.PermutedBinaryRows(dt.Cols[1], int(ss.InputPct), 1, 0)
def Init(ev, run):
ev.Draw.Init()
ev.Run.Scale = env.Run
ev.Epoch.Scale = env.Epoch
ev.Trial.Scale = env.Trial
ev.Run.Init()
ev.Epoch.Init()
ev.Trial.Init()
ev.Run.Cur = run
ev.Trial.Cur = -1 # init state -- key so that first Step() = 0
ev.Output.SetShape(go.Slice_int([4, 5]), go.nil,
go.Slice_string(["Y", "X"]))
def Init(ev, run):
ev.Run.Scale = env.Run
ev.Epoch.Scale = env.Epoch
ev.Trial.Scale = env.Trial
ev.Trial.Max = len(ev.Words)
ev.Run.Init()
ev.Epoch.Init()
ev.Trial.Init()
ev.Run.Cur = run
ev.Trial.Cur = -1
ev.WordState.SetShape(go.Slice_int([len(ev.Words)]), go.nil,
go.Slice_string(["Words"]))
def Init(ev, run):
ev.Run.Scale = env.Run
ev.Epoch.Scale = env.Epoch
ev.Trial.Scale = env.Trial
ev.Run.Init()
ev.Epoch.Init()
ev.Trial.Init()
ev.Run.Cur = run
ev.InitOrder()
nw = len(ev.Words)
ev.CurParaState.SetShape(go.Slice_int([nw]), go.nil,
go.Slice_string(["Words"]))
def WtWords(ss):
if ss.NetView.Data.PrjnLay != "Hidden":
log.Println("WtWords: must select unit in Hidden layer in NetView")
return go.nil
ly = ss.Net.LayerByName(ss.NetView.Data.PrjnLay)
slay = ss.Net.LayerByName("Input")
pvals = go.Slice_float32()
slay.SendPrjnVals(pvals, "Wt", ly, ss.NetView.Data.PrjnUnIdx, "")
ww = go.Slice_string()
for i, wrd in enumerate(ss.TrainEnv.Words):
wv = pvals[i]
if wv > ss.WtWordsThr:
ww.append(wrd)
giv.SliceViewDialogNoStyle(ss.vp, ww, giv.DlgOpts(Title="WtWords Result"), go.nil, go.nil)
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)
def UpdateEnv(ss):
if ss.Pats == PatsType.Easy:
ss.TrainEnv.Table = etable.NewIdxView(ss.Easy)
ss.TestEnv.Table = etable.NewIdxView(ss.Easy)
elif ss.Pats == PatsType.Hard:
ss.TrainEnv.Table = etable.NewIdxView(ss.Hard)
ss.TestEnv.Table = etable.NewIdxView(ss.Hard)
elif ss.Pats == PatsType.Impossible:
ss.TrainEnv.Table = etable.NewIdxView(ss.Impossible)
ss.TestEnv.Table = etable.NewIdxView(ss.Impossible)
elif ss.Pats == PatsType.Lines2:
all = etable.NewIdxView(ss.Lines2)
splits = split.Permuted(all, go.Slice_float64([.9, .1]), go.Slice_string(["Train", "Test"]))
ss.TrainEnv.Table = splits.Splits[0]
ss.TestEnv.Table = splits.Splits[1]
def Init(ev, run):
ev.Run.Scale = env.Run
ev.Epoch.Scale = env.Epoch
ev.Seq.Scale = env.Sequence
ev.Tick.Scale = env.Tick
ev.Trial.Scale = env.Trial
ev.Run.Init()
ev.Epoch.Init()
ev.Seq.Init()
ev.Tick.Init()
ev.Trial.Init()
ev.Run.Cur = run
ev.Trial.Cur = -1 # init state -- key so that first Step() = 0
ev.SentIdx.Set(-1)
ev.Rules.Init()
ev.MapsFmWords()
ev.WordState.SetShape(go.Slice_int([len(ev.Words)]), go.nil,
go.Slice_string(["Words"]))
ev.RoleState.SetShape(go.Slice_int([len(ev.Roles)]), go.nil,
go.Slice_string(["Roles"]))
ev.FillerState.SetShape(go.Slice_int([len(ev.Fillers)]), go.nil,
go.Slice_string(["Fillers"]))
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()
lays = go.Slice_string(["Input"])
for lnm in lays :
ly = leabra.Layer(ss.Net.LayerByName(lnm))
pats = en.State(ly.Nm)
if pats != 0:
ly.ApplyExt(pats)
def LogTstQuiz(ss, dt):
trl = ss.TstTrlLog
epc = ss.TrainEnv.Epoch.Prv # ?
nper = 4 # number of paras per quiz question: Q, A, B, C
nt = trl.Rows
nq = int(nt / nper)
pctcor = 0.0
srow = dt.Rows
dt.SetNumRows(srow + nq + 1)
for qi in range(nq):
ri = nper * qi
qv = etensor.Float64(trl.CellTensor("Hidden", ri))
mxai = 0
mxcor = 0.0
row = srow + qi
for ai in range(nper - 1):
av = etensor.Float64(trl.CellTensor("Hidden", ri+ai+1))
cor = metric.Correlation64(qv.Values, av.Values)
if cor > mxcor:
mxai = ai
mxcor = cor
dt.SetCellTensorFloat1D("Correls", row, ai, cor)
ans = go.Slice_string(["A", "B", "C"])[mxai]
err = 1.0
if mxai == 0: # A
pctcor += 1
err = 0
# note: this shows how to use agg methods to compute summary data from another
# data table, instead of incrementing on the Sim
dt.SetCellFloat("Run", row, float(ss.TrainEnv.Run.Cur))
dt.SetCellFloat("Epoch", row, float(epc))
dt.SetCellFloat("QNo", row, float(qi))
dt.SetCellString("Resp", row, ans)
dt.SetCellFloat("Err", row, err)
pctcor /= float(nq)
row = dt.Rows - 1
dt.SetCellFloat("Run", row, float(ss.TrainEnv.Run.Cur))
dt.SetCellFloat("Epoch", row, float(epc))
dt.SetCellFloat("QNo", row, -1)
dt.SetCellString("Resp", row, "Total")
dt.SetCellFloat("Err", row, pctcor)
ss.TstQuizPctCor = pctcor
# note: essential to use Go version of update when called from another goroutine
ss.TstQuizPlot.GoUpdate()
def TestAll(ss):
"""
TestAll runs through the full set of testing items
"""
err = ss.TestEnv.SetParas(go.Slice_string([ss.Words1, ss.Words2]))
if err != 0:
gi.PromptDialog(go.nil, gi.DlgOpts(Title= "Words errors",
Prompt= err.Error()), gi.AddOk, gi.NoCancel,
go.nil, go.nil)
return
ss.TestEnv.Init(ss.TrainEnv.Run.Cur)
while True:
ss.TestTrial(True)
chg = ss.TestEnv.CounterChg(env.Epoch)
if chg or ss.StopNow:
break
def __init__(self):
super(SemEnv, self).__init__()
self.Nm = str()
self.SetTags("Nm", 'desc:"name of this environment"')
self.Dsc = str()
self.SetTags("Dsc", 'desc:"description of this environment"')
self.Sequential = False
self.SetTags(
"Sequential",
'desc:"if true, go sequentially through paragraphs -- else permuted"'
)
self.Order = go.Slice_int()
self.SetTags(
"Order",
'desc:"permuted order of paras to present if not sequential -- updated every time through the list"'
)
self.TextFiles = []
self.SetTags("TextFiles", 'desc:"paths to text files"')
self.Words = go.Slice_string()
self.SetTags("Words", 'desc:"list of words, in alpha order"')
self.WordMap = {}
self.SetTags("WordMap",
'view:"-" desc:"map of words onto index in Words list"')
self.CurParaState = etensor.Float32()
self.SetTags("CurParaState", 'desc:"current para activation state"')
self.Paras = []
self.SetTags("Paras", 'view:"-" desc:"paragraphs"')
self.ParaLabels = []
self.SetTags(
"ParaLabels",
'view:"-" desc:"special labels for each paragraph (provided in first word of para)"'
)
self.Run = env.Ctr()
self.SetTags(
"Run",
'view:"inline" desc:"current run of model as provided during Init"'
)
self.Epoch = env.Ctr()
self.SetTags(
"Epoch",
'view:"inline" desc:"number of times through Seq.Max number of sequences"'
)
self.Trial = env.Ctr()
self.SetTags(
"Trial",
'view:"inline" desc:"trial is the step counter within epoch -- this is the index into Paras"'
)
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(["Input", "Emotion", "Gender", "Identity"])
for lnm in lays :
ly = leabra.LeabraLayer(ss.Net.LayerByName(lnm)).AsLeabra()
pats = en.State(ly.Nm)
if pats != 0:
ly.ApplyExt(pats)
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)