pfcRULEasso = spa.ThresholdingAssocMem(0.3,
input_vocab=vocab,
mapping=assoRule,
function=lambda x: 1
if x > 0.1 else 0,
label='pfcRULEasso')
stim_cue >> pfcRULEasso
pfcRULEasso >> pfcRULEmemo
# connections
stim_cue >> ppc
stim_cue >> pfcCUE
motorClean = spa.WTAAssocMem(threshold=0.1,
input_vocab=vocab,
output_vocab=vocab,
mapping=movesMap,
function=lambda x: 1 if x > 0.1 else 0,
label='motorClean')
nengo.Connection(mdRULE.output,
pfcRULEmemo.input,
transform=5,
synapse=0.05)
with spa.ActionSelection() as act_sel:
spa.ifmax(spa.dot(pfcRULEasso, s.AUD), s.AUD >> mdRULE)
spa.ifmax(spa.dot(pfcRULEasso, s.VIS), s.VIS >> mdRULE)
spa.ifmax(spa.dot(stim_target, s.AUD * s.RIGHT + s.VIS * s.LEFT),
stim_target * ~pfcRULEmemo >> motorClean)
spa.ifmax(spa.dot(stim_target, s.VIS * s.RIGHT + s.AUD * s.LEFT),
stim_target * ~pfcRULEmemo >> motorClean)
def model(self, p):
vocab_space = spa.Vocabulary(p.D_space, strict=False)
vocab_space.populate('OBJ1; OBJ2; OBJ3; OBJ4; OBJ5; X; Y')
vocab_rule = spa.Vocabulary(p.D)
vocab_rule.populate(
'OBJ1; OBJ2; OBJ3; OBJ4; OBJ5; BELOW; ABOVE; LEFT; RIGHT; S; O; V')
vocab_obj = vocab_rule.create_subset(
['OBJ1', 'OBJ2', 'OBJ3', 'OBJ4', 'OBJ5'])
vocab_rel = vocab_rule.create_subset(
['BELOW', 'ABOVE', 'LEFT', 'RIGHT'])
model = spa.Network()
with model:
rule = spa.State(vocab_rule)
objs = spa.State(feedback=1, vocab=vocab_space)
subject = spa.WTAAssocMem(threshold=0.3, input_vocab=vocab_obj)
object = spa.WTAAssocMem(threshold=0.3, input_vocab=vocab_obj)
relation = spa.WTAAssocMem(threshold=0.3, input_vocab=vocab_rel)
status = spa.State(p.D)
def input(t):
t = t % 1.6
if t < 0.4:
return 'OBJ1*S+LEFT*V+OBJ2*O'
elif t < 0.8:
return 'OBJ2*S+LEFT*V+OBJ3*O'
elif t < 1.2:
return 'OBJ3*S+LEFT*V+OBJ4*O'
elif t < 1.6:
return 'OBJ4*S+LEFT*V+OBJ5*O'
input = spa.Transcode(input, output_vocab=vocab_rule)
speed = 0.7
separation = 0.7
strength = 0.5
spa.Actions('''
input -> rule
reinterpret(rule*~S) ->subject
reinterpret(rule*~O) ->object
reinterpret(rule*~V) ->relation
ifmax (dot(relation, BELOW-ABOVE-LEFT-RIGHT)*strength +
(dot(objs, translate(subject)*Y) - dot(objs, translate(object)*Y)) +
separation):
BAD -> status
speed*Y*translate(object)-speed*Y*translate(subject) -> objs
elifmax (dot(relation, BELOW-ABOVE-LEFT-RIGHT)*strength -
(dot(objs, translate(subject)*Y) - dot(objs, translate(object)*Y)) -
separation):
GOOD -> status
ifmax (dot(relation, ABOVE-BELOW-LEFT-RIGHT)*strength +
(dot(objs, translate(subject)*Y) - dot(objs, translate(object)*Y)) +
separation):
BAD -> status
speed*Y*translate(object)-speed*Y*translate(subject) -> objs
elifmax (dot(relation, ABOVE-BELOW-LEFT-RIGHT)*strength -
(dot(objs, translate(subject)*Y) - dot(objs, translate(object)*Y)) -
separation):
GOOD -> status
ifmax (dot(relation, LEFT-RIGHT-ABOVE-BELOW)*strength +
(dot(objs, translate(subject)*X) - dot(objs, translate(object)*X)) +
separation):
BAD -> status
speed*X*translate(object)-speed*X*translate(subject) -> objs
elifmax (dot(relation, LEFT-RIGHT-ABOVE-BELOW)*strength -
(dot(objs, translate(subject)*X) - dot(objs, translate(object)*X)) -
separation):
GOOD -> status
ifmax (dot(relation, RIGHT-ABOVE-BELOW-LEFT)*strength +
(dot(objs, translate(subject)*X) - dot(objs, translate(object)*X)) +
separation):
BAD -> status
speed*X*translate(object)-speed*X*translate(subject) -> objs
elifmax (dot(relation, RIGHT-ABOVE-BELOW-LEFT)*strength -
(dot(objs, translate(subject)*X) - dot(objs, translate(object)*X)) -
separation):
GOOD -> status
''')
def display_node(t, x):
return x
display = nengo.Node(display_node, size_in=10)
nengo.Connection(objs.output,
display[0],
transform=[vocab_space.parse('OBJ1*X').v])
nengo.Connection(objs.output,
display[1],
transform=[vocab_space.parse('OBJ1*Y').v])
nengo.Connection(objs.output,
display[2],
transform=[vocab_space.parse('OBJ2*X').v])
nengo.Connection(objs.output,
display[3],
transform=[vocab_space.parse('OBJ2*Y').v])
nengo.Connection(objs.output,
display[4],
transform=[vocab_space.parse('OBJ3*X').v])
nengo.Connection(objs.output,
display[5],
transform=[vocab_space.parse('OBJ3*Y').v])
nengo.Connection(objs.output,
display[6],
transform=[vocab_space.parse('OBJ4*X').v])
nengo.Connection(objs.output,
display[7],
transform=[vocab_space.parse('OBJ4*Y').v])
nengo.Connection(objs.output,
display[8],
transform=[vocab_space.parse('OBJ5*X').v])
nengo.Connection(objs.output,
display[9],
transform=[vocab_space.parse('OBJ5*Y').v])
for net in model.networks:
if net.label is not None:
if net.label.startswith('dot'):
net.label = ''
if net.label.startswith('channel'):
net.label = ''
with model:
self.result = nengo.Probe(display, synapse=0.03)
return model
# state representation of input
target = spa.State(D, label='Target')
cue = spa.State(D, label='Cue')
motor = spa.State(dims, feedback = 1, label = 'motor')
# Connect to repreesentation of inputs
target_in >> target
cue_in >> cue
# pfc
pfc = spa.State(dims, feedback = pfcFB, label = 'pfc')
vocab = pfc.vocab
vocab.add('RULE1', vocab.parse('CUE_A+CUE_C'))
vocab.add('RULE2', vocab.parse('CUE_B+CUE_D'))
vocab.add('CONTEXT1', vocab.parse('CUE_A+CUE_B'))
vocab.add('CONTEXT2', vocab.parse('CUE_C+CUE_D'))
cue >> pfc
with spa.ActionSelection():
spa.ifmax( 0.5, s.X*0 >> pfc)
spa.ifmax( 0.8*spa.dot(pfc, s.RULE1) + 0.8*spa.dot(target, s.LIGHT*(s.RIGHT+s.LEFT)),
target*~s.LIGHT >> motor )
spa.ifmax( 0.8*spa.dot(pfc, s.RULE2) + 0.8*spa.dot(target, s.SOUND*(s.RIGHT+s.LEFT)),
target*~s.SOUND >> motor )
md = spa.WTAAssocMem(threshold = 0.5, input_vocab = pfc.vocab, mapping = map, label = 'MD')
pfc >> md
md*0.8 >> pfc
key_range(1, 11, 1) + ['D0=D1*~D1'] +
['GET_V ; GET_COM ; GET_ADD ; SET_COM ; SET_ADD ; SET_M'])
with spa.Network() as model:
input_INSTRUCTIONS = spa.Transcode(lambda t: '\
D1 * (GET_V) +\
D2 * (GET_ADD + SET_ADD) +\
D3 * (GET_COM + SET_COM) + \
D4 * (SET_M) \
',
output_vocab=vocab)
POS = WM(100, vocab)
clean_POS = spa.WTAAssocMem(threshold=.2,
input_vocab=POS.vocab,
mapping=['D1', 'D2', 'D3', 'D4'],
n_neurons=50,
function=lambda x: x > 0)
nengo.Connection(POS.output, clean_POS.input)
INCREMENT = WM(100, vocab)
PRIM = spa.Bind(neurons_per_dimension=200, vocab=vocab, unbind_right=True)
GET_PRIM = spa.WTAAssocMem(threshold=.5,
input_vocab=PRIM.vocab,
mapping=['GET_V', 'GET_COM', 'GET_ADD'],
n_neurons=50,
function=lambda x: x > 0)
SET_PRIM = spa.WTAAssocMem(threshold=.5,
input_vocab=PRIM.vocab,
mapping=['SET_COM', 'SET_ADD', 'SET_M'],
n_neurons=50,
###########
# Model 7 #
###########
# cleanup memories illustrated
with spa.Network() as model:
scene = spa.sym.RED * spa.sym.SQUARE + spa.sym.BLUE * spa.sym.CIRCLE
stim = spa.Transcode(lambda t: 'CIRCLE' if t < 0.25 else 'SQUARE',
output_vocab=dim)
unbind = spa.Transcode(lambda t, x: scene * ~x,
input_vocab=dim,
output_vocab=dim)
am = spa.WTAAssocMem(0.4, model.vocabs[dim])
stim >> unbind
unbind >> am
probe = nengo.Probe(am.output, synapse=0.01)
sim = nengo.Simulator(model)
sim.run(0.5)
plt.plot(sim.trange(), spa.similarity(sim.data[probe], model.vocabs[dim]))
plt.xlabel('time (s)')
plt.ylabel('similarity')
plt.legend(model.vocabs[dim].keys())
plt.show()
def construct_network(self):
self.send_n_neurons_per_dim()
s = spa.sym
net = self.network
# temporary parameters
self.crosstalk = False
self.crosstalk_lr = 5e-12
with net:
net.input_net = spa.Network(label='inputs', seed=self.seed)
with net.input_net:
net.input_net.RETINA_input = spa.Transcode(
self.experiment.RETINA_input,
input_vocab=self.vocabs['GW'],
output_vocab=self.vocabs['GW'])
net.V = DirectProcessor(
self.vocabs['GW'],
self.vocabs['GW'],
'V',
receiver=False, # V only sends info to GW
seed=self.seed,
prediction_out=self.crosstalk,
n_neurons_per_dim=self.n_neurons_per_dim)
nengo.Connection(net.input_net.RETINA_input.output,
net.V.input.input,
synapse=None)
net.FIXATE_detector = nengo.Node(size_in=1,
label='FIXATE detector')
nengo.Connection(
net.V.input.output,
net.FIXATE_detector,
transform=net.V.output_vocab.parse('FIXATE').v[None, :],
synapse=.05
) # some synaptic delay is necessary to ensure the stimulus has time to enter GW
net.declare_output(net.FIXATE_detector, None)
net.M = DirectProcessor(
self.vocabs['GW'],
self.vocabs['GW'],
'M',
sender=False, # M only receives info from GW
seed=self.seed,
n_neurons_per_dim=self.n_neurons_per_dim)
net.BTN = nengo.Node(Button(
SP_vectors=[
self.vocabs['GW'].parse('LESS').v,
self.vocabs['GW'].parse('MORE').v
],
trial_length=self.experiment.trial_length,
wait_length=self.experiment.t_start),
label='button',
size_in=self.vocabs['GW'].dimensions)
nengo.Connection(
net.M.output.output, net.BTN
) # Connect output of M to BTN that records behavioral response
net.ADD = ADDProcessor(self.vocabs['GW'],
'ADD',
self.n_neurons_per_dim,
self.rng,
self.BG_bias,
self.BG_thr,
feedback=self.proc_feedback,
seed=self.seed)
with net.input_net:
net.input_net.ADDEND = spa.Transcode(
self.experiment.ADDEND_input,
input_vocab=self.vocabs['GW'],
output_vocab=self.vocabs['GW'],
label='ADDEND')
nengo.Connection(net.input_net.ADDEND.output,
net.ADD.bind.input_right,
synapse=None)
if self.compare_tau != 0:
net.COM = CompareProcessor(
self.vocabs['GW'],
self.vocabs['GW'],
'COM',
self.experiment.trial_length,
self.experiment.t_start if self.integrator_reset else 0,
self.n_neurons_per_dim,
self.rng,
self.n_samples,
tau=self.compare_tau,
seed=self.seed,
prediction_in=self.crosstalk)
else:
net.COM = AMProcessor(self.vocabs['GW'],
self.vocabs['GW'],
'COM', {
'D2': 'LESS',
'D4': 'LESS',
'D6': 'MORE',
'D8': 'MORE'
},
n_neurons_per_dim=self.n_neurons_per_dim,
seed=self.seed,
prediction_in=self.crosstalk)
self.processors = [net.V, net.COM, net.M, net.ADD]
if self.crosstalk:
net.crosstalk = Prediction(net.V,
net.COM,
rate=self.crosstalk_lr)
net.GW = GlobalWorkspace(self.vocabs['GW'],
mappings={
net.V:
['D2', 'D4', 'D6', 'D8', 'FIXATE'],
net.ADD: ['D2', 'D4', 'D6', 'D8'],
net.COM: ['MORE', 'LESS'],
},
n_neurons=self.n_neurons_per_dim['AM'],
seed=self.seed)
for detector in net.GW.detectors.values():
net.declare_output(detector, None)
net.POS = WM(200, self.vocabs['PRIM'])
net.clean_POS = spa.WTAAssocMem(
threshold=0,
input_vocab=net.POS.vocab,
mapping=['D1', 'D2', 'D3', 'D4'],
n_neurons=self.n_neurons_per_dim['AM'],
function=lambda x: x > 0)
nengo.Connection(net.POS.output, net.clean_POS.input)
net.INCREMENT = WM(200, self.vocabs['PRIM'])
nengo.Connection(
net.clean_POS.output,
net.INCREMENT.input,
transform=net.POS.vocab.parse('D1').get_binding_matrix())
nengo.Connection(net.INCREMENT.output, net.POS.input)
with net.input_net:
net.input_net.INSTRUCTIONS = spa.Transcode(
self.experiment.INSTRUCTIONS_input,
input_vocab=self.vocabs['PRIM'],
output_vocab=self.vocabs['PRIM'],
label='INSTRUCTIONS')
net.PRIM = spa.Bind(
neurons_per_dimension=self.n_neurons_per_dim['Bind'],
vocab=self.vocabs['PRIM'],
unbind_right=True)
net.input_net.INSTRUCTIONS >> net.PRIM.input_left
net.clean_POS >> net.PRIM.input_right
# GET selector
with spa.Network(label='GET selector',
seed=self.seed) as net.GET_selector:
net.GET_selector.labels = []
with spa.ActionSelection() as net.GET_selector.AS:
net.GET_selector.labels.append("GET V (FIXATE)")
spa.ifmax(net.GET_selector.labels[-1],
self.BG_bias + net.FIXATE_detector,
net.V.preconscious >> net.GW.AMs[net.V].input,
s.D1 >> net.POS.input, 1 >> net.INCREMENT.reset)
net.GET_selector.labels.append("GET ADD")
spa.ifmax(
net.GET_selector.labels[-1],
self.BG_bias + spa.dot(net.PRIM, s.GET_ADD) *
(1 - net.GW.detectors[net.ADD]),
net.ADD.preconscious >> net.GW.AMs[net.ADD].input,
1 >> net.POS.gate,
)
net.GET_selector.labels.append("GET COM")
spa.ifmax(
net.GET_selector.labels[-1],
self.BG_bias + spa.dot(net.PRIM, s.GET_COM) *
(1 - net.GW.detectors[net.COM]),
net.COM.preconscious >> net.GW.AMs[net.COM].input,
1 >> net.POS.gate,
)
net.GET_selector.labels.append("Thresholder")
spa.ifmax(
net.GET_selector.labels[-1],
self.BG_bias + self.BG_thr,
1 >> net.INCREMENT.gate,
)
# SET selector
with spa.Network(label='SET selector',
seed=self.seed) as net.SET_selector:
net.SET_selector.labels = []
with spa.ActionSelection() as net.SET_selector.AS:
net.SET_selector.labels.append("SET ADD")
spa.ifmax(
net.SET_selector.labels[-1],
self.BG_bias + spa.dot(net.PRIM, s.SET_ADD) *
(1 - net.GW.detectors[net.ADD]),
net.GW.AMs[net.COM] >> net.ADD.broadcast,
net.GW.AMs[net.V] >> net.ADD.broadcast,
)
net.SET_selector.labels.append("SET COM")
spa.ifmax(
net.SET_selector.labels[-1],
self.BG_bias + spa.dot(net.PRIM, s.SET_COM) *
(1 - net.GW.detectors[net.COM]),
net.GW.AMs[net.ADD] >> net.COM.broadcast,
net.GW.AMs[net.V] >> net.COM.broadcast,
)
net.SET_selector.labels.append("SET M")
spa.ifmax(
net.SET_selector.labels[-1],
self.BG_bias + spa.dot(net.PRIM, s.SET_M),
net.GW.AMs[net.COM] >> net.M.broadcast,
net.GW.AMs[net.V] >> net.M.broadcast,
net.GW.AMs[net.ADD] >> net.M.broadcast,
)
net.SET_selector.labels.append("Thresholder")
spa.ifmax(net.SET_selector.labels[-1], self.BG_bias +
self.BG_thr) # Threshold for action
errorPPC = spa.State(vocab, feedback = 0.05, label = 'errPPC')
errorRULE = spa.State(vocab, feedback = 0.05, label = 'errRULE')
# define inputs
stim_cue = spa.Transcode( function = exp.presentCues, output_vocab = vocab, label='stim Cue')
stim_target = spa.Transcode( function = exp.presentTargets, output_vocab = vocab, label='stim Target')
# connections
nengo.Connection(md.output, pfcRULE.input, synapse=0.05)
#md >> pfcRULE
stim_cue >> ppc
stim_cue >> pfcCUE
motorClean = spa.WTAAssocMem(threshold=0.1, input_vocab=vocab,
mapping = movesMap,
label = 'motorClean')
#ppc >> ppcClean
#motor >> motorClean
pfcRULE - md >> pfcRULE
with spa.ActionSelection():
spa.ifmax(0.3*spa.dot(s.NOTHING, pfcCUE),s.NOTHING >> pfcRULE)
spa.ifmax(spa.dot(s.CUE_A + s.CUE_C, pfcCUE),
s.VIS >> pfcRULE)
spa.ifmax(spa.dot(s.CUE_B + s.CUE_D, pfcCUE),
s.AUD >> pfcRULE)
spa.ifmax(spa.dot(stim_target, s.AUD*s.RIGHT+s.VIS*s.LEFT),
stim_target*~pfcRULE >> motorClean)