def __init__(self,
vocab=Default,
feedback=1.,
feedback_syn=.1,
diff_scale=100.,
subdimensions=16,
**kwargs):
super(GatedMemory, self).__init__(**kwargs)
self.vocab = vocab
with self:
self.diff = spa.State(self.vocab)
self.mem = spa.State(self.vocab,
subdimensions=subdimensions,
feedback=feedback,
feedback_synapse=feedback_syn)
self.input_store = nengo.Node(size_in=1)
nengo.Connection(self.diff.output,
self.mem.input,
transform=diff_scale * feedback_syn,
synapse=feedback_syn)
nengo.Connection(self.mem.output, self.diff.input, transform=-1)
inhibit_net(self.input_store,
self.diff.state_ensembles,
strength=3.)
self.input = self.diff.input
self.output = self.mem.output
self.inputs = dict(default=(self.diff.input, vocab),
store=(self.input_store, None))
self.outputs = dict(default=(self.mem.output, vocab))
def __init__(self,
input_vocab=Default,
output_vocab=Default,
init_transform=None,
learning_rate=1.,
decay=1.,
**kwargs):
super(UnconstrainedAssocMatLearning, self).__init__(**kwargs)
self.input_vocab = input_vocab
self.output_vocab = output_vocab
with self:
self.state = spa.State(self.input_vocab, subdimensions=64)
for e in self.state.all_ensembles:
e.radius = 0.5
e.intercepts = nengo.dists.Uniform(-1., 1.)
e.eval_points = nengo.dists.UniformHypersphere(surface=False)
self.target = spa.State(self.output_vocab)
self.input_cue = self.state.input
self.input_target = self.target.input
self.output = nengo.Node(size_in=self.output_vocab.dimensions)
self.input_scale = nengo.Node(size_in=1)
self.input_no_learn = nengo.Node(size_in=1)
inhibit_net(self.input_no_learn, self.target)
for i, e in enumerate(self.state.all_ensembles):
sd = e.dimensions
start = i * sd
end = (i + 1) * sd
conn = nengo.Connection(
e,
self.output[start:end],
learning_rule_type=AML(sd, learning_rate),
function=lambda x, sd=sd: np.zeros(sd), # noqa, pylint: disable=undefined-variable
solver=nengo.solvers.LstsqL2(solver=RandomizedSVD()))
n = nengo.Node(size_in=sd + 2)
nengo.Connection(self.target.output[start:end], n[2:])
nengo.Connection(self.input_scale, n[0], synapse=None)
nengo.Connection(nengo.Node(decay), n[1], synapse=None)
nengo.Connection(n, conn.learning_rule)
if init_transform is not None:
nengo.Connection(self.state.output,
self.output,
transform=init_transform)
self.inputs = {
'default': (self.input_cue, self.input_vocab),
'target': (self.input_target, self.output_vocab),
'no_learn': (self.input_no_learn, None),
'scale': (self.input_scale, None)
}
self.outputs = {'default': (self.output, self.output_vocab)}
def BoundedIntegrator(d, beta, **kwargs):
kwargs.setdefault('label', "context.BoundedIntegrator")
net = nengo.Network(**kwargs)
with net:
net.input = nengo.Node(size_in=d)
net.bias_node = nengo.Node(1)
net.gate = spa.State(d)
net.current = spa.State(d, feedback=1, neurons_per_dimension=300)
net.dot = spa.Compare(d)
with nengo.presets.ThresholdingEnsembles(0.):
net.update_done = nengo.Ensemble(150, 1)
net.update_done_th = nengo.Node(size_in=1)
nengo.Connection(net.input, net.gate.input, synapse=None)
nengo.Connection(net.input, net.dot.input_a)
nengo.Connection(net.gate.output, net.current.input, transform=0.3)
nengo.Connection(net.current.output, net.dot.input_b)
nengo.Connection(net.dot.output, net.update_done)
nengo.Connection(net.bias_node, net.update_done, transform=-beta)
nengo.Connection(net.update_done,
net.update_done_th,
synapse=None,
function=lambda x: x > 0)
inhibit_net(net.update_done_th, net.gate, strength=3.)
ctx_square = net.current.state_ensembles.add_output(
'square', lambda x: x * x)
with nengo.presets.ThresholdingEnsembles(-0.1):
net.length = nengo.Ensemble(150, 1)
nengo.Connection(ctx_square, net.length, transform=-np.ones((1, d)))
nengo.Connection(net.bias_node, net.length)
net.downscale = spa.State(d)
nengo.Connection(net.current.output, net.downscale.input)
nengo.Connection(net.downscale.output,
net.current.input,
transform=-0.1)
inhibit_net(net.length,
net.downscale,
strength=3,
function=lambda x: 1 if x >= -0.1 else 0)
net.output = net.current.output
return net
def __init__(self,
input_vocab=Default,
output_vocab=Default,
init_transform=None,
decay=1.,
**kwargs):
super(AssocMatLearning, self).__init__(input_vocab,
output_vocab,
init_transform,
learning_rate=10.,
decay=decay,
**kwargs)
with self:
self.compare = SimilarityThreshold(self.output_vocab)
nengo.Connection(self.output, self.compare.input_a)
nengo.Connection(self.input_target, self.compare.input_b)
inhibit_net(self.compare.output, self.target, strength=1.)
def __init__(
self, protocol, task_vocabs, beta, gamma=0.9775, ose_thr=0.2,
ordinal_prob=0.2, recall_noise=0., min_evidence=0.025,
decay=1., extensions=None, **kwargs):
kwargs.setdefault('label', 'CUE')
super(CUE, self).__init__(**kwargs)
if extensions is None:
extensions = set()
self.task_vocabs = task_vocabs
with self:
self.config[spa.State].represent_identity = False
self.bias = nengo.Node(1.)
self.ctrl = Control(protocol, self.task_vocabs.items)
# TCM
self.tcm = TCM(
self.task_vocabs, beta, extensions=extensions, decay=decay)
nengo.Connection(self.ctrl.output_stimulus, self.tcm.input)
nengo.Connection(self.ctrl.output_lr, self.tcm.input_scale)
# position counter
self.pos = OneHotCounter(len(self.task_vocabs.positions))
nengo.Connection(
self.ctrl.output_no_pos_count, self.pos.rising_edge_gate,
transform=-1.)
nengo.Connection(nengo.Node(lambda t: t < 0.3), self.pos.input[0])
# Short term memory
self.ose = OSE(self.task_vocabs.items, gamma)
nengo.Connection(self.ctrl.output_stimulus, self.ose.input_item)
# primacy effect
def primacy(t):
epoch_t = t % protocol.epoch_duration
if epoch_t < protocol.pres_phase_duration:
return -np.exp(-epoch_t)
else:
return 0.
nengo.Connection(
nengo.Node(primacy), self.tcm.net_m_tf.compare.threshold)
self.serial_recall_phase = nengo.Ensemble(50, 1)
nengo.Connection(
self.ctrl.output_serial_recall, self.serial_recall_phase)
nengo.Connection(
self.ctrl.output_pres_phase, self.serial_recall_phase,
transform=-1.)
nengo.Connection(
self.ctrl.output_free_recall, self.serial_recall_phase.neurons,
transform=-3. * np.ones(
(self.serial_recall_phase.n_neurons, 1)))
# Use irrelevant position vector to bind distractors
self.in_pos_gate = spa.State(self.task_vocabs.positions)
nengo.Connection(self.pos.output, self.in_pos_gate.input,
transform=self.task_vocabs.positions.vectors.T)
nengo.Connection(self.in_pos_gate.output, self.ose.input_pos)
if 'no_pos_input' not in extensions:
nengo.Connection(self.in_pos_gate.output, self.tcm.input_pos)
inhibit_net(self.ctrl.output_no_learn, self.in_pos_gate, strength=10.)
self.irrelevant_pos_gate = spa.State(self.task_vocabs.positions)
self.irrelevant_pos = nengo.Node(
self.task_vocabs.positions.create_pointer().v)
nengo.Connection(self.irrelevant_pos,
self.irrelevant_pos_gate.input)
nengo.Connection(
self.irrelevant_pos_gate.output, self.ose.input_pos)
with nengo.presets.ThresholdingEnsembles(0.):
self.in_pos_gate_inhibit = nengo.Ensemble(25, 1)
inhibit_net(self.in_pos_gate_inhibit, self.in_pos_gate)
nengo.Connection(
self.ctrl.output_no_learn, self.in_pos_gate_inhibit)
nengo.Connection(
self.ctrl.output_recall_phase, self.in_pos_gate_inhibit,
transform=-1)
inhibit_net(self.ctrl.output_learn, self.irrelevant_pos_gate)
inhibit_net(
self.ctrl.output_recall_phase, self.irrelevant_pos_gate)
inhibit_net(self.ctrl.bias, self.irrelevant_pos_gate)
if 'no_pos_input' not in extensions:
nengo.Connection(self.irrelevant_pos_gate.output, self.tcm.input_pos)
inhibit_net(self.ctrl.output_no_learn, self.irrelevant_pos_gate, strength=10.)
# Reset of position
# Happens only in serial recall and a certain fraction of free
# recalls.
with nengo.presets.ThresholdingEnsembles(0.):
self.start_of_free_recall = nengo.Ensemble(50, 1)
self.start_of_serial_recall = nengo.Ensemble(50, 1)
self.start_of_pres_phase = nengo.Ensemble(50, 1)
nengo.Connection(
self.ctrl.output_recall_phase, self.start_of_free_recall,
synapse=0.05, transform=-1)
nengo.Connection(
self.ctrl.output_recall_phase, self.start_of_free_recall,
synapse=0.005)
nengo.Connection(
self.ctrl.output_recall_phase, self.start_of_serial_recall,
synapse=0.05, transform=-1)
nengo.Connection(
self.ctrl.output_recall_phase, self.start_of_serial_recall,
synapse=0.005)
nengo.Connection(
self.ctrl.output_pres_phase, self.start_of_pres_phase,
synapse=0.05, transform=-1)
nengo.Connection(
self.ctrl.output_pres_phase, self.start_of_pres_phase,
synapse=0.005)
tr = -9 * np.ones((self.pos.input.size_in, 1))
tr[0, 0] = 3.
nengo.Connection(
self.start_of_serial_recall, self.pos.input, transform=tr,
synapse=0.1)
if 'recognition' not in extensions:
nengo.Connection(
self.start_of_serial_recall, self.tcm.input_pos,
transform=np.atleast_2d(
self.task_vocabs.positions.vectors[0]).T,
synapse=0.1)
inhibit_net(self.start_of_free_recall, self.pos, strength=10.)
nengo.Connection(
self.start_of_pres_phase, self.pos.input, transform=tr,
synapse=0.1)
if 'recognition' not in extensions:
nengo.Connection(
self.start_of_pres_phase, self.tcm.input_pos,
transform=np.atleast_2d(
self.task_vocabs.positions.vectors[0]).T,
synapse=0.1)
# Certain fraction of recalls use ordinal strategy
if np.random.rand() >= ordinal_prob:
nengo.Connection(
self.ctrl.output_free_recall, self.start_of_serial_recall,
transform=-5.)
nengo.Connection(
self.ctrl.output_serial_recall, self.start_of_free_recall,
transform=-5.)
else:
nengo.Connection(
self.ctrl.output_free_recall, self.start_of_free_recall,
transform=-5.)
nengo.Connection(
self.ctrl.output_serial_recall, self.start_of_free_recall,
transform=-5.)
# Determining update progress
self.last_item = spa.State(self.task_vocabs.items, feedback=1.)
self.sim_th = SimilarityThreshold(self.task_vocabs.items)
nengo.Connection(
self.ctrl.output_stimulus, self.last_item.input, transform=1.,
synapse=0.1)
nengo.Connection(self.ctrl.output_stimulus, self.sim_th.input_a)
nengo.Connection(self.last_item.output, self.sim_th.input_b)
if 'forward-assoc' in extensions:
self.cc = spa.Bind(self.task_vocabs.items)
nengo.Connection(
self.pos.output_prev, self.cc.input_b,
transform=self.task_vocabs.positions.vectors.T)
nengo.Connection(
self.cc.output, self.tcm.forward_assoc.input_cue)
self.stage_a = GatedMemory(self.task_vocabs.items)
self.stage_b = GatedMemory(self.task_vocabs.items)
nengo.Connection(self.ctrl.output_stimulus, self.stage_a.input)
nengo.Connection(self.stage_a.output, self.stage_b.input)
nengo.Connection(self.stage_b.output, self.cc.input_a)
inhibit_net(self.ctrl.output_recall_phase, self.stage_a)
inhibit_net(self.ctrl.output_recall_phase, self.stage_b)
nengo.Connection(self.sim_th.output, self.stage_b.input_store)
nengo.Connection(
nengo.Node(1.), self.stage_a.input_store, synapse=None)
nengo.Connection(
self.sim_th.output, self.stage_a.input_store,
transform=-1.)
self.sim_th2 = SimilarityThreshold(self.task_vocabs.items)
nengo.Connection(self.stage_a.output, self.sim_th2.input_a)
nengo.Connection(
self.ctrl.output_stimulus, self.sim_th2.input_b)
nengo.Connection(
self.sim_th2.output, self.stage_a.input_store, synapse=0.1)
with nengo.Config(nengo.Ensemble) as cfg:
cfg[nengo.Ensemble].eval_points = nengo.dists.Uniform(0, 1)
cfg[nengo.Ensemble].intercepts = nengo.dists.Uniform(0, 1)
self.sim_th_pos = nengo.Ensemble(50, 1)
self.sim_th_neg = nengo.Ensemble(50, 1)
nengo.Connection(self.sim_th.output, self.sim_th_pos)
nengo.Connection(self.sim_th.output, self.sim_th_neg)
nengo.Connection(self.ctrl.output_pres_phase, self.sim_th_pos.neurons, transform=-3. * np.ones((self.sim_th_pos.n_neurons, 1)))
nengo.Connection(self.ctrl.output_recall_phase, self.sim_th_neg.neurons, transform=-3. * np.ones((self.sim_th_neg.n_neurons, 1)))
nengo.Connection(self.sim_th_pos, self.pos.input_inc)
nengo.Connection(self.sim_th_neg, self.pos.input_inc, transform=-1)
nengo.Connection(self.ctrl.output_pres_phase, self.tcm.input_update_context)
nengo.Connection(
self.sim_th_neg, self.tcm.input_update_context,
transform=-1.) # FIXME ?
nengo.Connection(
self.sim_th_pos, self.tcm.input_update_context,
transform=1.) # FIXME ?
# nengo.Connection(
# self.sim_th.output, self.pos.input_inc, transform=-1)
nengo.Connection(self.sim_th.output, self.ose.input_store)
nengo.Connection(self.bias, self.tcm.input_no_learn)
nengo.Connection(
self.sim_th.output, self.tcm.input_no_learn, transform=-1)
nengo.Connection(
self.ctrl.output_no_learn, self.tcm.input_no_learn,
transform=2.)
# Recall networks
self.recall = NeuralAccumulatorDecisionProcess(
self.task_vocabs.items.create_subset(protocol.get_all_items()),
noise=recall_noise, min_evidence=min_evidence, n_inputs=2)
self.recalled_gate = spa.State(self.task_vocabs.items)
if 'recognition' not in extensions:
nengo.Connection(self.recalled_gate.output, self.tcm.input)
self.pos_recall = NeuralAccumulatorDecisionProcess(
self.task_vocabs.positions, noise=recall_noise,
min_evidence=min_evidence)
self.tcm_recall_gate = spa.State(self.task_vocabs.items)
if 'disable_ltm_recall' not in extensions:
nengo.Connection(
self.tcm.output_recalled_item, self.tcm_recall_gate.input)
inhibit_net(self.ctrl.output_pres_phase, self.tcm_recall_gate)
inhibit_net(
self.ctrl.output_serial_recall, self.recalled_gate, strength=6)
nengo.Connection(self.recall.output, self.recalled_gate.input)
for recall_net in (self.recall, self.pos_recall):
nengo.Connection(
self.tcm_recall_gate.output, recall_net.input_list[0])
inhibit_net(self.ctrl.output_pres_phase, recall_net.state)
inhibit_net(
self.ctrl.output_pres_phase, recall_net.buf.mem,
strength=6)
inhibit_net(self.ctrl.output_pres_phase, recall_net.inhibit)
if 'forward-assoc' in extensions:
nengo.Connection(self.recall.output, self.cc.input_a)
nengo.Connection(
self.recall.output, self.sim_th.input_a, transform=1.2)
nengo.Connection(
self.recall.output, self.last_item.input, transform=0.1,
synapse=0.1)
nengo.Connection(
self.bias, self.recall.out_inhibit_gate.input_store)
nengo.Connection(
self.sim_th.output, self.recall.out_inhibit_gate.input_store,
transform=-1)
# on failed recall increment pos and update context
nengo.Connection(
self.recall.failed_recall_heaviside, self.pos.input_inc,
transform=50., synapse=0.1)
nengo.Connection(
self.recall.failed_recall_heaviside,
self.tcm.input_update_context, transform=20.)
# Set position from recalled positions
self.pos_gate = nengo.networks.EnsembleArray(
30, len(self.task_vocabs.positions))
nengo.Connection(
self.pos_recall.buf.output, self.pos_gate.input,
transform=1.3 * self.task_vocabs.positions.vectors)
nengo.Connection(
self.bias, self.pos_gate.input,
transform=-np.ones((self.pos_gate.input.size_in, 1)))
nengo.Connection(
self.pos_gate.output, self.pos.input, transform=10.,
synapse=0.1)
self.invert = nengo.Ensemble(30, 1)
nengo.Connection(self.bias, self.invert)
nengo.Connection(
self.pos_recall.buf.mem.state_ensembles.add_output(
'square', lambda x: x * x),
self.invert,
transform=-np.ones((1, self.task_vocabs.positions.dimensions)))
inhibit_net(self.invert, self.pos_gate)
inhibit_net(self.ctrl.output_serial_recall, self.pos_gate)
inhibit_net(self.ctrl.output_serial_recall, self.pos_recall.buf)
# Short term recall
self.ose_recall_gate = spa.State(self.task_vocabs.items)
if 'disable_stm_recall' not in extensions:
nengo.Connection(
self.ose.output, self.ose_recall_gate.input, transform=0.5)
nengo.Connection(
self.ose_recall_gate.output, self.recall.input_list[1])
self.ose_recall_threshold = nengo.Node(ose_thr)
nengo.Connection(
self.ose_recall_threshold, self.recall.inp_thrs[1].input,
transform=-np.ones(
(self.recall.inp_thrs[1].input.size_in, 1)))
inhibit_net(self.ctrl.output_pres_phase, self.ose_recall_gate)
inhibit_net(self.start_of_serial_recall, self.ose_recall_gate)
inhibit_net(self.start_of_serial_recall, self.tcm.current_ctx.old.mem,
synapse=0.1, strength=5)
nengo.Connection(
self.start_of_serial_recall, self.tcm.input_update_context,
synapse=0.1, transform=5)
self.output = self.recall.output
self.output_pos = self.pos.output
self.outputs = dict(
default=(self.output, self.task_vocabs.items),
output_pos=(self.output_pos, self.task_vocabs.positions))
def __init__(self,
vocab=Default,
noise=0.,
min_evidence=0.,
n_inputs=1,
**kwargs):
super(NeuralAccumulatorDecisionProcess, self).__init__(**kwargs)
self.vocab = vocab
n_items, d = self.vocab.vectors.shape
with self:
assert n_inputs > 0
self.input_list = [nengo.Node(size_in=d) for _ in range(n_inputs)]
# Input rectification
with nengo.presets.ThresholdingEnsembles(0.):
self.inp_thrs = [
nengo.networks.EnsembleArray(50, n_items)
for _ in range(n_inputs)
]
# Evidence integration
with nengo.presets.ThresholdingEnsembles(0.):
self.state = nengo.networks.EnsembleArray(50, n_items + 1)
for inp, inp_thr in zip(self.input_list, self.inp_thrs):
nengo.Connection(inp,
inp_thr.input,
transform=self.vocab.vectors,
synapse=None)
nengo.Connection(inp_thr.output,
self.state.input[:-1],
transform=0.1)
self.bias = nengo.Node(1.)
nengo.Connection(self.bias,
self.state.input[-1],
transform=min_evidence)
nengo.Connection(self.state.output, self.state.input, synapse=0.1)
# Thresholding layer
with nengo.presets.ThresholdingEnsembles(0.8):
self.threshold = nengo.networks.EnsembleArray(50, n_items + 1)
nengo.Connection(self.state.output, self.threshold.input)
tr = -2 * (1. - np.eye(n_items + 1)) + 1. * np.eye(n_items + 1)
nengo.Connection(self.threshold.add_output(
'heaviside', lambda x: 1 if x > 0.8 else 0.),
self.state.input,
transform=tr,
synapse=0.1)
# Buffer for recalled item
self.buf = GatedMemory(self.vocab, diff_scale=10.)
nengo.Connection(self.threshold.heaviside[:-1],
self.buf.diff.input,
transform=self.vocab.vectors.T)
self.buf_input_store = nengo.Ensemble(25, 1)
nengo.Connection(self.buf_input_store, self.buf.input_store)
nengo.Connection(nengo.Node(1.), self.buf_input_store)
nengo.Connection(self.threshold.heaviside[:-1],
self.buf_input_store.neurons,
transform=-2. * np.ones(
(self.buf_input_store.n_neurons, n_items)))
# Inhibition of recalled items
self.inhibit = spa.State(self.vocab, feedback=1.)
self.inhibit_gate = spa.State(self.vocab)
nengo.Connection(self.buf.mem.output, self.inhibit_gate.input)
nengo.Connection(self.inhibit_gate.output,
self.inhibit.input,
synapse=0.1,
transform=0.1)
self.cmp = spa.Compare(self.vocab, neurons_per_dimension=50)
nengo.Connection(self.buf.mem.output, self.cmp.input_a)
nengo.Connection(self.inhibit.output, self.cmp.input_b)
with nengo.presets.ThresholdingEnsembles(0.):
self.inhibit_update_done = nengo.Ensemble(50, 1)
nengo.Connection(nengo.Node(-0.5), self.inhibit_update_done)
nengo.Connection(self.cmp.output, self.inhibit_update_done)
inhibit_net(self.inhibit_update_done,
self.inhibit_gate,
function=lambda x: x > 0)
with nengo.presets.ThresholdingEnsembles(0.1):
self.inhib_thr = nengo.networks.EnsembleArray(50, n_items)
# nengo.Connection(
# self.inhibit.output, self.inhib_thr.input,
# transform=self.vocab.vectors)
self.out_inhibit_gate = GatedMemory(self.vocab)
nengo.Connection(self.inhibit.output, self.out_inhibit_gate.input)
nengo.Connection(self.out_inhibit_gate.output,
self.inhib_thr.input,
transform=self.vocab.vectors)
nengo.Connection(self.inhib_thr.output,
self.state.input[:-1],
transform=-6.)
# Start over if recall fails
self.failed_recall_int = nengo.Ensemble(50, 1)
nengo.Connection(self.failed_recall_int,
self.failed_recall_int,
synapse=0.1,
transform=0.9)
nengo.Connection(self.threshold.heaviside[-1],
self.failed_recall_int,
transform=0.1,
synapse=0.1)
with nengo.presets.ThresholdingEnsembles(0.):
self.failed_recall = nengo.Ensemble(50, 1)
nengo.Connection(self.failed_recall_int, self.failed_recall)
nengo.Connection(nengo.Node(1.),
self.failed_recall,
transform=-0.3)
self.failed_recall_heaviside = nengo.Node(size_in=1)
nengo.Connection(self.failed_recall,
self.failed_recall_heaviside,
function=lambda x: x > 0.)
for e in self.state.ensembles:
nengo.Connection(self.failed_recall_heaviside,
e.neurons,
transform=-50. * np.ones((e.n_neurons, 1)),
synapse=0.1)
# Noise on input
if noise > 0.:
self.noise = nengo.Node(nengo.processes.WhiteNoise(
dist=nengo.dists.Gaussian(mean=0., std=noise)),
size_out=n_items + 1)
nengo.Connection(self.noise, self.state.input)
self.output = self.buf.output
self.inputs = dict(default=(self.input_list[0], self.vocab))
self.outputs = dict(default=(self.output, self.vocab))