def test_am_spa_keys_as_expressions(Simulator, plt, seed, rng):
"""Provide semantic pointer expressions as input and output keys."""
D = 64
vocab_in = Vocabulary(D, rng=rng)
vocab_out = Vocabulary(D, rng=rng)
vocab_in.parse("A+B")
vocab_out.parse("C+D")
in_keys = ["A", "A*B"]
out_keys = ["C*D", "C+D"]
with nengo.spa.SPA(seed=seed) as model:
model.am = AssociativeMemory(
input_vocab=vocab_in,
output_vocab=vocab_out,
input_keys=in_keys,
output_keys=out_keys,
)
model.inp = Input(am=lambda t: "A" if t < 0.1 else "A*B")
in_p = nengo.Probe(model.am.input)
out_p = nengo.Probe(model.am.output, synapse=0.03)
with Simulator(model) as sim:
sim.run(0.2)
# Specify t ranges
t = sim.trange()
t_item1 = (t > 0.075) & (t < 0.1)
t_item2 = (t > 0.175) & (t < 0.2)
# Modify vocabularies (for plotting purposes)
vocab_in.add(in_keys[1], vocab_in.parse(in_keys[1]).v)
vocab_out.add(out_keys[0], vocab_out.parse(out_keys[0]).v)
plt.subplot(2, 1, 1)
plt.plot(t, similarity(sim.data[in_p], vocab_in))
plt.ylabel("Input: " + ", ".join(in_keys))
plt.legend(vocab_in.keys, loc="best")
plt.ylim(top=1.1)
plt.subplot(2, 1, 2)
plt.plot(t, similarity(sim.data[out_p], vocab_out))
plt.plot(t[t_item1], np.ones(t.shape)[t_item1] * 0.9, c="r", lw=2)
plt.plot(t[t_item2], np.ones(t.shape)[t_item2] * 0.91, c="g", lw=2)
plt.plot(t[t_item2], np.ones(t.shape)[t_item2] * 0.89, c="b", lw=2)
plt.ylabel("Output: " + ", ".join(out_keys))
plt.legend(vocab_out.keys, loc="best")
assert (np.mean(
similarity(sim.data[out_p][t_item1],
vocab_out.parse(out_keys[0]).v,
normalize=True)) > 0.9)
assert (np.mean(
similarity(sim.data[out_p][t_item2],
vocab_out.parse(out_keys[1]).v,
normalize=True)) > 0.9)
def test_am_spa_keys_as_expressions(Simulator, plt, seed, rng):
"""Provide semantic pointer expressions as input and output keys."""
D = 64
vocab_in = Vocabulary(D, rng=rng)
vocab_out = Vocabulary(D, rng=rng)
vocab_in.parse('A+B')
vocab_out.parse('C+D')
in_keys = ['A', 'A*B']
out_keys = ['C*D', 'C+D']
with nengo.spa.SPA(seed=seed) as model:
model.am = AssociativeMemory(input_vocab=vocab_in,
output_vocab=vocab_out,
input_keys=in_keys,
output_keys=out_keys)
model.inp = Input(am=lambda t: 'A' if t < 0.1 else 'A*B')
in_p = nengo.Probe(model.am.input)
out_p = nengo.Probe(model.am.output, synapse=0.03)
with Simulator(model) as sim:
sim.run(0.2)
# Specify t ranges
t = sim.trange()
t_item1 = (t > 0.075) & (t < 0.1)
t_item2 = (t > 0.175) & (t < 0.2)
# Modify vocabularies (for plotting purposes)
vocab_in.add(in_keys[1], vocab_in.parse(in_keys[1]).v)
vocab_out.add(out_keys[0], vocab_out.parse(out_keys[0]).v)
plt.subplot(2, 1, 1)
plt.plot(t, similarity(sim.data[in_p], vocab_in))
plt.ylabel("Input: " + ', '.join(in_keys))
plt.legend(vocab_in.keys, loc='best')
plt.ylim(top=1.1)
plt.subplot(2, 1, 2)
plt.plot(t, similarity(sim.data[out_p], vocab_out))
plt.plot(t[t_item1], np.ones(t.shape)[t_item1] * 0.9, c='r', lw=2)
plt.plot(t[t_item2], np.ones(t.shape)[t_item2] * 0.91, c='g', lw=2)
plt.plot(t[t_item2], np.ones(t.shape)[t_item2] * 0.89, c='b', lw=2)
plt.ylabel("Output: " + ', '.join(out_keys))
plt.legend(vocab_out.keys, loc='best')
assert np.mean(similarity(sim.data[out_p][t_item1],
vocab_out.parse(out_keys[0]).v,
normalize=True)) > 0.9
assert np.mean(similarity(sim.data[out_p][t_item2],
vocab_out.parse(out_keys[1]).v,
normalize=True)) > 0.9
def generate(input_signal, alpha=1000.0):
beta = alpha / 4.0
# Read in the class mean for numbers from vision network
weights_data = np.load('models/mnist_vision_data/params.npz')
weights = weights_data['Wc']
means_data = np.load('models/mnist_vision_data/class_means.npz')
means = np.matrix(1.0 / means_data['means'])
sps = np.multiply(weights.T, means.T)[:10]
sps_labels = [
'ZERO', 'ONE', 'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT',
'NINE'
]
dimensions = weights.shape[0]
# generate the Function Space
forces, _, goals = forcing_functions.load_folder(
'models/handwriting_trajectories',
rhythmic=False,
alpha=alpha,
beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
# store the weights for each number
weights_x = []
weights_y = []
for ii in range(len(goals)):
forces = force_space[ii * 2:ii * 2 + 2]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_x.append(np.dot(fs.basis.T, forces[0]))
weights_y.append(np.dot(fs.basis.T, forces[1]))
# Create our vocabularies
rng = np.random.RandomState(0)
vocab_vision = Vocabulary(dimensions=dimensions, rng=rng)
vocab_dmp_weights_x = Vocabulary(dimensions=fs.n_basis + 2, rng=rng)
vocab_dmp_weights_y = Vocabulary(dimensions=fs.n_basis + 2, rng=rng)
for label, sp, wx, wy, goal in zip(sps_labels, sps, weights_x, weights_y,
goals):
vocab_vision.add(label,
np.array(sp)[0] / np.linalg.norm(np.array(sp)[0]))
vocab_dmp_weights_x.add(label, np.hstack([wx, goal[0][0], goal[1][0]]))
vocab_dmp_weights_y.add(label, np.hstack([wy, goal[0][1], goal[1][1]]))
net = spa.SPA()
# net.config[nengo.Ensemble].neuron_type = nengo.Direct()
with net:
# def input_func(t):
# return vocab_vision.parse(input_signal).v
# net.input = nengo.Node(input_func, label='input')
net.input = spa.State(dimensions, subdimensions=10, vocab=vocab_vision)
time_func = lambda t: min(max((t * 2) % 4 - 2.5, -1), 1)
timer_node = nengo.Node(output=time_func, label='timer')
# ------------------- Point Attractors --------------------
def goals_func(t, x):
if (x[0] + 1) < 1e-5:
return x[1], x[2]
return x[3], x[4]
goal_node = nengo.Node(goals_func,
size_in=5,
size_out=2,
label='goals')
nengo.Connection(timer_node, goal_node[0])
net.x = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(goal_node[0], net.x.input[0], synapse=None)
net.y = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(goal_node[1], net.y.input[0], synapse=None)
# -------------------- Ramp ------------------------------
ramp_node = nengo.Node(output=time_func, label='ramp node')
ramp = nengo.Ensemble(n_neurons=1000, dimensions=1, label='ramp')
nengo.Connection(ramp_node, ramp)
# ------------------- Forcing Functions --------------------
net.assoc_mem_x = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_x,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_x.input)
nengo.Connection(net.assoc_mem_x.output[[-2, -1]], goal_node[[1, 3]])
net.assoc_mem_y = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_y,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_y.input)
nengo.Connection(net.assoc_mem_y.output[[-2, -1]], goal_node[[2, 4]])
# -------------------- Product for decoding -----------------------
net.product_x = nengo.Network('Product X')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_x,
input_magnitude=1.0)
net.product_y = nengo.Network('Product Y')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_y,
input_magnitude=1.0)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis * fs.scale)
domain = np.linspace(-1, 1, fs.basis.shape[0])
for ff, product in zip(
[net.assoc_mem_x.output, net.assoc_mem_y.output],
[net.product_x, net.product_y]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of x
def basis_fn(x, jj=ii):
index = int(x[0] * len(domain) / 2.0 + len(domain) / 2.0)
index = max(min(index, len(domain) - 1), 0)
return fs.basis[index][jj] * fs.scale / max_basis
# multiply the value of each basis function at x by its weight
nengo.Connection(ramp, product.B[ii], function=basis_fn)
nengo.Connection(ff[ii], product.A[ii])
def relay_func(t, x):
t = time_func(t)
if t <= -1:
return [0, 0]
return x
relay = nengo.Node(output=relay_func,
size_in=2,
size_out=2,
label='relay')
nengo.Connection(net.product_x.output,
relay[0],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(net.product_y.output,
relay[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(relay[0], net.x.input[1], synapse=None)
nengo.Connection(relay[1], net.y.input[1], synapse=None)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=2)
nengo.Connection(net.x.output, net.output[0], synapse=0.01)
nengo.Connection(net.y.output, net.output[1], synapse=0.01)
# create a node to give a plot of the represented function
ff_plot = fs.make_plot_node(domain=domain, lines=2, ylim=[-75, 75])
nengo.Connection(net.assoc_mem_x.output[:fs.n_basis],
ff_plot[:fs.n_basis],
synapse=0.1)
nengo.Connection(net.assoc_mem_y.output[:fs.n_basis],
ff_plot[fs.n_basis:],
synapse=0.1)
return net
class SpaunVocabulary(object):
def __init__(self):
self.main = None
self.sp_dim = 512
self.mtr_dim = 50
self.vis_dim = 200
# ############ Semantic pointer (strings) definitions #################
# --- Numerical semantic pointers ---
self.num_sp_strs = ['ZER', 'ONE', 'TWO', 'THR', 'FOR',
'FIV', 'SIX', 'SEV', 'EIG', 'NIN']
self.n_num_sp = len(self.num_sp_strs)
# --- Task semantic pointer list ---
# W - Drawing (Copying visual input)
# R - Recognition
# L - Learning (Bandit Task)
# M - Memory (forward serial recall)
# C - Counting
# A - Answering
# V - Rapid Variable Creation
# F - Fluid Induction (Ravens)
# X - Task precursor
# DEC - Decoding task (output to motor system)
self.ps_task_sp_strs = ['W', 'R', 'L', 'M', 'C', 'A', 'V', 'F', 'X',
'DEC', 'REACT', 'INSTR', 'CMP']
self.ps_task_vis_sp_strs = ['A', 'C', 'F', 'K', 'L', 'M', 'P', 'R',
'V', 'W']
# --- Task visual semantic pointer usage ---
# A - Task initialization
# F - Forward recall
# R - Reverse recall
# K - Q&A 'kind' probe
# P - Q&A 'position' probe
# --- Production system semantic pointers ---
# DECW - Decoding state (output to motor system, but for drawing task)
# DECI - Decoding state (output to motor system, but for inductn tasks)
self.ps_state_sp_strs = ['QAP', 'QAK', 'TRANS0', 'TRANS1', 'TRANS2',
'CNT0', 'CNT1', 'LEARN', 'DIRECT', 'INSTRP',
'INSTRV', 'TRANSC']
self.ps_dec_sp_strs = ['FWD', 'REV', 'CNT', 'DECW', 'DECI', 'NONE']
# --- Misc actions semantic pointers
self.ps_action_sp_strs = None
self.min_num_ps_actions = 3
# --- Misc visual semantic pointers ---
self.misc_vis_sp_strs = ['OPEN', 'CLOSE', 'SPACE', 'QM']
# --- Misc state semantic pointers ---
self.misc_ps_sp_strs = ['NO_MATCH', 'MATCH']
# --- 'I don't know' motor response vector
self.mtr_sp_strs = ['UNK']
# --- List of all visual semantic pointers ---
# self.vis_sp_strs = list(self.num_sp_strs)
# self.vis_sp_strs.extend(self.misc_vis_sp_strs)
# self.vis_sp_strs.extend(self.ps_task_vis_sp_strs)
# --- Position (enumerated) semantic pointers ---
self.pos_sp_strs = None
self.max_enum_list_pos = 8
# --- Operations semantic pointers
self.ops_sp_strs = ['ADD', 'INC']
# --- Reward semantic pointers
self.reward_n_sp_str = self.num_sp_strs[0]
self.reward_y_sp_str = self.num_sp_strs[1]
self.reward_sp_strs = [self.reward_n_sp_str, self.reward_y_sp_str]
# --- Instruction processing input and output tags
self.instr_tag_strs = ['VIS', 'TASK', 'STATE', 'DEC', 'DATA', 'ENABLE']
def write_header(self):
logger.write('# Spaun Vocabulary Options:\n')
logger.write('# -------------------------\n')
for param_name in sorted(self.__dict__.keys()):
param_value = getattr(self, param_name)
if not callable(param_value) and not isinstance(param_value, list)\
and not isinstance(param_value, Vocabulary) \
and not isinstance(param_value, SemanticPointer) \
and not isinstance(param_value, np.ndarray):
logger.write('# - %s = %s\n' % (param_name, param_value))
logger.write('\n')
def initialize(self, stim_SP_labels, num_learn_actions=3, rng=0):
if rng == 0:
rng = np.random.RandomState(int(time.time()))
# ############### Semantic pointer list definitions ###################
# --- Position (enumerated) semantic pointers ---
self.pos_sp_strs = ['POS%i' % (i + 1)
for i in range(self.max_enum_list_pos)]
# --- Unitary semantic pointers
self.unitary_sp_strs = [self.num_sp_strs[0], self.pos_sp_strs[0]]
self.unitary_sp_strs.extend(self.ops_sp_strs)
# --- Production system (action) semantic pointers ---
self.ps_action_learn_sp_strs = ['A%d' % (i + 1) for i in
range(num_learn_actions)]
self.ps_action_misc_sp_strs = []
self.ps_action_sp_strs = (self.ps_action_learn_sp_strs +
self.ps_action_misc_sp_strs)
# #################### Vocabulary definitions #########################
# --- Primary vocabulary ---
self.main = Vocabulary(self.sp_dim, unitary=self.unitary_sp_strs,
max_similarity=0.2, rng=rng)
# --- Add in visual sp's ---
self.main.parse('+'.join(self.misc_vis_sp_strs))
self.main.parse('+'.join(self.ps_task_vis_sp_strs))
for sp_str in list(stim_SP_labels):
if sp_str not in self.num_sp_strs and \
sp_str not in self.pos_sp_strs:
self.main.parse(sp_str)
# --- Add numerical sp's ---
self.main.parse('%s+%s' % (self.ops_sp_strs[0], self.num_sp_strs[0]))
add_sp = self.main[self.ops_sp_strs[0]]
num_sp = self.main[self.num_sp_strs[0]].copy()
for i in range(len(self.num_sp_strs) - 1):
num_sp = num_sp.copy() * add_sp
self.main.add(self.num_sp_strs[i + 1], num_sp)
self.add_sp = add_sp
# --- Add positional sp's ---
self.main.parse('%s+%s' % (self.ops_sp_strs[1], self.pos_sp_strs[0]))
inc_sp = self.main[self.ops_sp_strs[1]]
pos_sp = self.main[self.pos_sp_strs[0]].copy()
for i in range(len(self.pos_sp_strs) - 1):
pos_sp = pos_sp.copy() * inc_sp
self.main.add(self.pos_sp_strs[i + 1], pos_sp)
self.inc_sp = inc_sp
# --- Add production system sp's ---
self.main.parse('+'.join(self.ps_task_sp_strs))
self.main.parse('+'.join(self.ps_state_sp_strs))
self.main.parse('+'.join(self.ps_dec_sp_strs))
if len(self.ps_action_sp_strs) > 0:
self.main.parse('+'.join(self.ps_action_sp_strs))
self.main.parse('+'.join(self.misc_ps_sp_strs))
# --- Add instruction processing system sp's ---
self.main.parse('+'.join(self.instr_tag_strs))
# ################### Visual Vocabulary definitions ###################
self.vis_sp_strs = list(stim_SP_labels)
# Visual sp str vocab check
if (not all(x in self.vis_sp_strs for x in self.num_sp_strs)):
raise RuntimeError("Vocabulator - Stimulus vocabulary does not " +
"contain necessary Spaun NUM semantic pointer" +
" definitions.")
if (not all(x in self.vis_sp_strs for x in self.misc_vis_sp_strs)):
raise RuntimeError("Vocabulator - Stimulus vocabulary does not " +
"contain necessary Spaun MISC semantic " +
"pointer definitions.")
if (not all(x in self.vis_sp_strs for x in self.ps_task_vis_sp_strs)):
raise RuntimeError("Vocabulator - Stimulus vocabulary does not " +
"contain necessary Spaun PS semantic " +
"pointer definitions.")
# ################# Sub-vocabulary definitions ########################
self.vis_main = self.main.create_subset(self.vis_sp_strs)
self.pos = self.main.create_subset(self.pos_sp_strs)
self.item = self.main.create_subset(self.num_sp_strs)
self.item_1_index = self.main.create_subset(self.num_sp_strs[1:])
self.ps_task = self.main.create_subset(self.ps_task_sp_strs)
self.ps_state = self.main.create_subset(self.ps_state_sp_strs)
self.ps_dec = self.main.create_subset(self.ps_dec_sp_strs)
self.ps_cmp = self.main.create_subset(self.misc_ps_sp_strs)
self.ps_action = self.main.create_subset(self.ps_action_sp_strs)
self.ps_action_learn = \
self.main.create_subset(self.ps_action_learn_sp_strs)
self.reward = self.main.create_subset(self.reward_sp_strs)
self.instr = self.main.create_subset(self.instr_tag_strs)
# ############ Enumerated vocabulary definitions ######################
# --- Enumerated vocabulary, enumerates all possible combinations of
# position and item vectors (for debug purposes)
self.enum = Vocabulary(self.sp_dim, rng=rng)
for pos in self.pos_sp_strs:
for num in self.num_sp_strs:
sp_str = '%s*%s' % (pos, num)
self.enum.add(sp_str, self.main.parse(sp_str))
self.pos1 = Vocabulary(self.sp_dim, rng=rng)
for num in self.num_sp_strs:
sp_str = '%s*%s' % (self.pos_sp_strs[0], num)
self.pos1.add(sp_str, self.main.parse(sp_str))
# ############ Instruction vocabulary definitions #####################
# --- ANTECEDENT and CONSEQUENCE permutation transforms
self.perm_ant = np.arange(self.sp_dim)
self.perm_con = np.arange(self.sp_dim)
np.random.shuffle(self.perm_ant)
np.random.shuffle(self.perm_con)
self.perm_ant_inv = np.argsort(self.perm_ant)
self.perm_con_inv = np.argsort(self.perm_con)
def initialize_mtr_vocab(self, mtr_dim, mtr_sps):
self.mtr_dim = mtr_dim
self.mtr = Vocabulary(self.mtr_dim)
for i, sp_str in enumerate(self.num_sp_strs):
self.mtr.add(sp_str, mtr_sps[i, :])
self.mtr_unk = Vocabulary(self.mtr_dim)
self.mtr_unk.add(self.mtr_sp_strs[0], mtr_sps[-1, :])
self.mtr_disp = self.mtr.create_subset(self.num_sp_strs)
self.mtr_disp.readonly = False
# Disable read-only flag for display vocab so that things can be added
self.mtr_disp.add(self.mtr_sp_strs[0],
self.mtr_unk[self.mtr_sp_strs[0]].v)
def initialize_vis_vocab(self, vis_dim, vis_sps):
if vis_sps.shape[0] != len(self.vis_sp_strs):
raise RuntimeError('Vocabulatory.initialize_vis_vocab: ' +
'Mismatch in shape of raw vision SPs and ' +
'number of vision SP labels.')
self.vis_dim = vis_dim
self.vis = Vocabulary(self.vis_dim)
for i, sp_str in enumerate(self.vis_sp_strs):
self.vis.add(sp_str, vis_sps[i, :])
def parse_instr_sps_list(self, instr_sps_list):
instr_sps_list_sp = self.main.parse('0')
if len(instr_sps_list) > self.max_enum_list_pos:
raise ValueError('Vocabulator: Too many sequential ' +
'instructions. Max: %d' %
self.max_enum_list_pos + ', Got: ' +
len(instr_sps_list))
for i, instr_sps in enumerate(instr_sps_list):
instr_sps_list_sp += (self.main.parse('POS%i' % (i + 1)) *
self.parse_instr_sps(*instr_sps))
return instr_sps_list_sp
def parse_instr_sps(self, ant_sp='0', cons_sp='0'):
# Note: The ant and con permutations are used here to separate the
# possible POS tags in the ant/con from the instruction POS tag.
# This permutation is not necessary if the instruction POS tags
# differ from the number-representation POS tags.
return SemanticPointer(self.main.parse(ant_sp).v[self.perm_ant] +
self.main.parse(cons_sp).v[self.perm_con])
import nengo
import nengo.spa as spa
from nengo.spa import Vocabulary
import numpy as np
D = 32 # the dimensionality of the vectors
rng = np.random.RandomState(7)
vocab = Vocabulary(dimensions=D, rng=rng, max_similarity=0.1)
#Adding semantic pointers to the vocabulary
CIRCLE = vocab.parse('CIRCLE')
BLUE = vocab.parse('BLUE')
RED = vocab.parse('RED')
SQUARE = vocab.parse('SQUARE')
ZERO = vocab.add('ZERO', [0] * D)
model = spa.SPA(label="Question Answering with Memory", vocabs=[vocab])
with model:
model.A = spa.State(D, label="color")
model.B = spa.State(D, label="shape")
model.C = spa.State(D, label="cue")
model.D = spa.State(D, label="bound")
model.E = spa.State(D, label="output")
model.memory = spa.State(D, feedback=1, label="memory")
actions = spa.Actions('D = A * B', 'memory = D', 'E = memory * ~C')
model.cortical = spa.Cortical(actions)
def main():
print "Loading Word2Vec model..."
word2vec_model = gensim.models.Word2Vec.load("word2vec_model_1_cleaned")
word2vec_model.init_sims(replace=True)
word2vec_vocab = word2vec_model.index2word
import readline
readline.parse_and_bind("tab: complete")
def complete(text,state):
results = [x for x in word2vec_vocab if x.startswith(text)] + [None]
return results[state]
readline.set_completer(complete)
print "This program uses an SPA network in Nengo to perform vector operations on a semantically structured word-vector space *learned* from a sentence corpus."
print "When trained on a large corpus of English sentences, for example, it should produce: Vector[king] - Vector[man] + Vector[woman] = Vector[king]"
print "For now, it just does subtraction..."
print "\nPress <tab> twice to see all your autocomplete options."
print "_______________________________________________________"
line1 = raw_input('\nFirst word:> ')
line2 = raw_input('\nSecond word:> ')
if line1 and line2 in word2vec_vocab:
val1 = word2vec_model[line1]
val2 = word2vec_model[line2]
diff = val1 - val2
dot_products = [np.dot(word2vec_model[word2vec_model.index2word[i]], diff) for i in range(len(word2vec_model.index2word))]
closest_word = word2vec_model.index2word[dot_products.index(max(dot_products))]
print "\nWhat the Nengo model SHOULD return is something like: %s" % closest_word
print "\nDefining SPA network..."
model = spa.SPA(label = "Vector Storage")
with model:
# Dimensionality of each representation
num_dimensions = 100
sub_dimensions = 1
# Create the vocabulary
vocab = Vocabulary(num_dimensions, randomize = False)
stored_value_1 = val1
vocab.add("Stored_value_1", stored_value_1)
stored_value_2 = val2
vocab.add("Stored_value_2", stored_value_2)
# Create a semantic pointer corresponding to the "correct" answer for the operation
sum_vector = np.subtract(stored_value_1, stored_value_2)
sum_vector = sum_vector/np.linalg.norm(sum_vector)
vocab.add("Correct_target", sum_vector)
# Define the control signal inputs as random vectors
r1 = [1] * num_dimensions
r1 = r1 / np.linalg.norm(r1)
r2 = [(-1)**k for k in range(num_dimensions)]
r2 = r2 / np.linalg.norm(r2)
vocab.add("Hold_signal", r1)
vocab.add("Start_signal", r2)
# Control when the vector operation takes place
def control_input(t):
if t < 1:
return "Hold_signal"
else:
return "Start_signal"
# Control buffer
model.control = spa.Buffer(dimensions = num_dimensions, subdimensions = sub_dimensions, neurons_per_dimension = 200, direct = True, vocab = vocab)
control_probe = nengo.Probe(model.control.state.output)
# Inputs to the word input buffers
def first_input(t):
return "Stored_value_1"
def second_input(t):
return "Stored_value_2"
# Buffers to store the inputs:
model.word_buffer1 = spa.Buffer(dimensions = num_dimensions, subdimensions = sub_dimensions, neurons_per_dimension = 200, direct = True, vocab = vocab)
model.word_buffer2 = spa.Buffer(dimensions = num_dimensions, subdimensions = sub_dimensions, neurons_per_dimension = 200, direct = True, vocab = vocab)
# Probe to visualize the values stored in the buffers
buffer_1_probe = nengo.Probe(model.word_buffer1.state.output)
buffer_2_probe = nengo.Probe(model.word_buffer2.state.output)
# Buffer to hold the result:
model.result = spa.Buffer(dimensions = num_dimensions, subdimensions = sub_dimensions, neurons_per_dimension = 200, direct = True, vocab = vocab)
result_probe = nengo.Probe(model.result.state.output)
# Control system
actions = spa.Actions('dot(control, Start_signal) --> result = word_buffer1 - word_buffer2', 'dot(control, Hold_signal) --> result = Hold_signal')
model.bg = spa.BasalGanglia(actions)
model.thalamus = spa.Thalamus(model.bg, subdim_channel = sub_dimensions)
# Connect up the inputs
model.input = spa.Input(control = control_input, word_buffer1 = first_input, word_buffer2 = second_input)
# Start the simulator
sim = nengo.Simulator(model)
# Dynamic plotting
plt.ion() # Dynamic updating of plots
fig = plt.figure(figsize=(15,8))
plt.show()
ax = fig.gca()
ax.set_title("Vector Storage")
while True:
sim.run(0.5) # Run for an additional 1 second
plt.clf() # Clear the figure
plt.plot(sim.trange(), similarity(sim.data, result_probe, vocab), label = "Buffer 3 Value")
legend_symbols = vocab.keys
plt.legend(legend_symbols, loc = 2)
plt.draw() # Re-draw
# Go back to our manually-stored vocabulary and see how well it did
diff = sim.data[result_probe][-1]
dot_products = [np.dot(word2vec_model[word2vec_model.index2word[i]], diff) for i in range(len(word2vec_model.index2word))]
closest_word = word2vec_model.index2word[dot_products.index(max(dot_products))]
print "Time: %f" % sim.trange()[-1]
print "\nWhat the Nengo model DID return is something like: %s" % closest_word
print "\n"
plt.show()
def main():
model = spa.SPA(label="Vector Storage")
with model:
# Dimensionality of each representation
num_dimensions = 2
sub_dimensions = 2
# Create the vocabulary
vocab = Vocabulary(num_dimensions, randomize = False)
# Form the inputs
stored_value_1 = [1] * num_dimensions
stored_value_1 = [s/np.linalg.norm(stored_value_1) for s in stored_value_1]
vocab.add("Stored_value_1", stored_value_1)
stored_value_2 = [(-1**i) for i in range(num_dimensions)]
stored_value_2 = [s/np.linalg.norm(stored_value_2) for s in stored_value_2]
vocab.add("Stored_value_2", stored_value_2)
def first_input(t):
if t < 10:
return "Stored_value_2"
else:
return "Stored_value_1"
def second_input(t):
if t < 5:
return "Stored_value_1"
else:
return "Stored_value_2"
# Buffers to store the input
model.buffer1 = spa.Buffer(dimensions = num_dimensions, subdimensions = sub_dimensions, neurons_per_dimension = 200, direct = True)
model.buffer2 = spa.Buffer(dimensions = num_dimensions, subdimensions = sub_dimensions, neurons_per_dimension = 200, direct = True)
# Probe to visualize the values stored in the buffers
buffer_1_probe = nengo.Probe(model.buffer1.state.output)
buffer_2_probe = nengo.Probe(model.buffer2.state.output)
# Connect up the inputs
model.input = spa.Input(buffer1 = first_input)
model.input = spa.Input(buffer2 = second_input)
# Buffer to store the output
model.buffer3 = spa.Buffer(dimensions = num_dimensions, subdimensions = sub_dimensions, neurons_per_dimension = 200, direct = True)
buffer_3_probe = nengo.Probe(model.buffer3.state.output)
# Control system
actions = spa.Actions('dot(buffer1, Stored_value_2) --> buffer3=Stored_value_2', 'dot(buffer1, Stored_value_1) --> buffer3=Stored_value_1+Stored_value_2')
model.bg = spa.BasalGanglia(actions)
model.thalamus = spa.Thalamus(model.bg)
# Start the simulator
sim = nengo.Simulator(model)
# Dynamic plotting
plt.ion() # Dynamic updating of plots
fig = plt.figure(figsize=(15,8))
plt.show()
ax = fig.gca()
ax.set_title("Vector Storage")
while True:
sim.run(1) # Run for an additional 1 second
plt.clf() # Clear the figure
plt.plot(sim.trange(), similarity(sim.data, buffer_1_probe, vocab), label = "Buffer 1 Value") # Plot the entire dataset so far
plt.plot(sim.trange(), similarity(sim.data, buffer_2_probe, vocab), label = "Buffer 2 Value")
plt.plot(sim.trange(), similarity(sim.data, buffer_3_probe, vocab), label = "Buffer 3 Value")
print sim.data[buffer_1_probe][-1]
print sim.data[buffer_2_probe][-1]
print sim.data[buffer_3_probe][-1]
plt.legend(vocab.keys * 3, loc = 2)
plt.draw() # Re-draw
class SpaunVocabulary(object):
def __init__(self):
self.main = None
self.sp_dim = 512
self.mtr_dim = 50
self.vis_dim = 200
# ############ Semantic pointer (strings) definitions #################
# --- Numerical semantic pointers ---
self.num_sp_strs = ['ZER', 'ONE', 'TWO', 'THR', 'FOR',
'FIV', 'SIX', 'SEV', 'EIG', 'NIN']
self.n_num_sp = len(self.num_sp_strs)
# --- Task semantic pointer list ---
# W - Drawing (Copying visual input)
# R - Recognition
# L - Learning (Bandit Task)
# M - Memory (forward serial recall)
# C - Counting
# A - Answering
# V - Rapid Variable Creation
# F - Fluid Induction (Ravens)
# X - Task precursor
# DEC - Decoding task (output to motor system)
self.ps_task_sp_strs = ['W', 'R', 'L', 'M', 'C', 'A', 'V', 'F', 'X',
'DEC']
self.ps_task_vis_sp_strs = ['A', 'C', 'F', 'K', 'L', 'M', 'P', 'R',
'V', 'W']
# --- Task visual semantic pointer usage ---
# A - Task initialization
# F - Forward recall
# R - Reverse recall
# K - Q&A 'kind' probe
# P - Q&A 'position' probe
# --- Production system semantic pointers ---
# DECW - Decoding state (output to motor system, but for drawing task)
# DECI - Decoding state (output to motor system, but for inductn tasks)
self.ps_state_sp_strs = ['QAP', 'QAK', 'TRANS0', 'TRANS1', 'TRANS2',
'CNT0', 'CNT1', 'LEARN']
self.ps_dec_sp_strs = ['FWD', 'REV', 'CNT', 'DECW', 'DECI', 'NONE']
# --- Misc actions semantic pointers
self.ps_action_sp_strs = None
self.min_num_ps_actions = 3
# --- Misc visual semantic pointers ---
self.misc_vis_sp_strs = ['OPEN', 'CLOSE', 'SPACE', 'QM']
# --- Misc state semantic pointers ---
self.misc_ps_sp_strs = ['MATCH', 'NO_MATCH']
# --- 'I don't know' motor response vector
self.mtr_sp_strs = ['UNK']
# --- List of all visual semantic pointers ---
self.vis_sp_strs = list(self.num_sp_strs)
self.vis_sp_strs.extend(self.misc_vis_sp_strs)
self.vis_sp_strs.extend(self.ps_task_vis_sp_strs)
# --- Position (enumerated) semantic pointers ---
self.pos_sp_strs = None
self.max_enum_list_pos = 8
# --- Operations semantic pointers
self.ops_sp_strs = ['ADD', 'INC']
# --- Reward semantic pointers
self.reward_n_sp_str = self.num_sp_strs[0]
self.reward_y_sp_str = self.num_sp_strs[1]
self.reward_sp_strs = [self.reward_n_sp_str, self.reward_y_sp_str]
def write_header(self):
logger.write('# Spaun Vocabulary Options:\n')
logger.write('# -------------------------\n')
for param_name in sorted(self.__dict__.keys()):
param_value = getattr(self, param_name)
if not callable(param_value) and not isinstance(param_value, list)\
and not isinstance(param_value, Vocabulary) \
and not isinstance(param_value, SemanticPointer) \
and not isinstance(param_value, np.ndarray):
logger.write('# - %s = %s\n' % (param_name, param_value))
logger.write('\n')
def initialize(self, num_learn_actions=3, rng=0):
if rng == 0:
rng = np.random.RandomState(int(time.time()))
# ############### Semantic pointer list definitions ###################
# --- Position (enumerated) semantic pointers ---
self.pos_sp_strs = ['POS%i' % (i + 1)
for i in range(self.max_enum_list_pos)]
# --- Unitary semantic pointers
self.unitary_sp_strs = [self.num_sp_strs[0], self.pos_sp_strs[0]]
self.unitary_sp_strs.extend(self.ops_sp_strs)
# --- Production system (action) semantic pointers ---
self.ps_action_learn_sp_strs = ['A%d' % (i + 1) for i in
range(num_learn_actions)]
self.ps_action_misc_sp_strs = []
self.ps_action_sp_strs = (self.ps_action_learn_sp_strs +
self.ps_action_misc_sp_strs)
# #################### Vocabulary definitions #########################
# --- Primary vocabulary ---
self.main = Vocabulary(self.sp_dim, unitary=self.unitary_sp_strs,
rng=rng)
# --- Add numerical sp's ---
self.main.parse('%s+%s' % (self.ops_sp_strs[0], self.num_sp_strs[0]))
add_sp = self.main[self.ops_sp_strs[0]]
num_sp = self.main[self.num_sp_strs[0]].copy()
for i in range(len(self.num_sp_strs) - 1):
num_sp = num_sp.copy() * add_sp
self.main.add(self.num_sp_strs[i + 1], num_sp)
self.add_sp = add_sp
# --- Add positional sp's ---
self.main.parse('%s+%s' % (self.ops_sp_strs[1], self.pos_sp_strs[0]))
inc_sp = self.main[self.ops_sp_strs[1]]
pos_sp = self.main[self.pos_sp_strs[0]].copy()
for i in range(len(self.pos_sp_strs) - 1):
pos_sp = pos_sp.copy() * inc_sp
self.main.add(self.pos_sp_strs[i + 1], pos_sp)
self.inc_sp = inc_sp
# --- Add other visual sp's ---
self.main.parse('+'.join(self.misc_vis_sp_strs))
self.main.parse('+'.join(self.ps_task_vis_sp_strs))
# --- Add production system sp's ---
self.main.parse('+'.join(self.ps_task_sp_strs))
self.main.parse('+'.join(self.ps_state_sp_strs))
self.main.parse('+'.join(self.ps_dec_sp_strs))
if len(self.ps_action_sp_strs) > 0:
self.main.parse('+'.join(self.ps_action_sp_strs))
self.main.parse('+'.join(self.misc_ps_sp_strs))
# ################# Sub-vocabulary definitions ########################
self.vis_main = self.main.create_subset(self.vis_sp_strs)
self.pos = self.main.create_subset(self.pos_sp_strs)
self.item = self.main.create_subset(self.num_sp_strs)
self.ps_task = self.main.create_subset(self.ps_task_sp_strs)
self.ps_state = self.main.create_subset(self.ps_state_sp_strs)
self.ps_dec = self.main.create_subset(self.ps_dec_sp_strs)
self.ps_cmp = self.main.create_subset(self.misc_ps_sp_strs)
self.ps_action = self.main.create_subset(self.ps_action_sp_strs)
self.ps_action_learn = \
self.main.create_subset(self.ps_action_learn_sp_strs)
self.reward = self.main.create_subset(self.reward_sp_strs)
# ############ Enumerated vocabulary definitions ######################
# --- Enumerated vocabulary, enumerates all possible combinations of
# position and item vectors (for debug purposes)
self.enum = Vocabulary(self.sp_dim, rng=rng)
for pos in self.pos_sp_strs:
for num in self.num_sp_strs:
sp_str = '%s*%s' % (pos, num)
self.enum.add(sp_str, self.main.parse(sp_str))
self.pos1 = Vocabulary(self.sp_dim, rng=rng)
for num in self.num_sp_strs:
sp_str = '%s*%s' % (self.pos_sp_strs[0], num)
self.pos1.add(sp_str, self.main.parse(sp_str))
def initialize_mtr_vocab(self, mtr_dim, mtr_sps):
self.mtr_dim = mtr_dim
self.mtr = Vocabulary(self.mtr_dim)
for i, sp_str in enumerate(self.num_sp_strs):
self.mtr.add(sp_str, mtr_sps[i, :])
self.mtr_unk = Vocabulary(self.mtr_dim)
self.mtr_unk.add(self.mtr_sp_strs[0], mtr_sps[-1, :])
self.mtr_disp = self.mtr.create_subset(self.num_sp_strs)
self.mtr_disp.readonly = False
# Disable read-only flag for display vocab so that things can be added
self.mtr_disp.add(self.mtr_sp_strs[0],
self.mtr_unk[self.mtr_sp_strs[0]].v)
def initialize_vis_vocab(self, vis_dim, vis_sps):
self.vis_dim = vis_dim
self.vis = Vocabulary(self.vis_dim)
for i, sp_str in enumerate(self.vis_sp_strs):
self.vis.add(sp_str, vis_sps[i, :])
# --- Unitary semantic pointers
unitary_sp_strs = [num_sp_strs[0], pos_sp_strs[0]]
unitary_sp_strs.extend(ops_sp_strs)
# ####################### Vocabulary definitions ##############################
# --- Primary vocabulary ---
vocab = Vocabulary(cfg.sp_dim, unitary=unitary_sp_strs, rng=cfg.rng)
# --- Add numerical sp's ---
vocab.parse('%s+%s' % (ops_sp_strs[0], num_sp_strs[0]))
add_sp = vocab[ops_sp_strs[0]]
num_sp = vocab[num_sp_strs[0]].copy()
for i in range(len(num_sp_strs) - 1):
num_sp = num_sp.copy() * add_sp
vocab.add(num_sp_strs[i + 1], num_sp)
# --- Add positional sp's ---
vocab.parse('%s+%s' % (ops_sp_strs[1], pos_sp_strs[0]))
inc_sp = vocab[ops_sp_strs[1]]
pos_sp = vocab[pos_sp_strs[0]].copy()
for i in range(len(pos_sp_strs) - 1):
pos_sp = pos_sp.copy() * inc_sp
vocab.add(pos_sp_strs[i + 1], pos_sp)
# --- Add other visual sp's ---
vocab.parse('+'.join(misc_vis_sp_strs))
vocab.parse('+'.join(ps_task_vis_sp_strs))
# --- Add production system sp's ---
vocab.parse('+'.join(ps_task_sp_strs))
# show the sum of A and B as represented by the object Sum (left - shows the
# semantic pointer representation in Sum, right - shows high similarity with
# vecotors A and B).
# Setup the environment
import nengo
import nengo.spa as spa
from nengo.spa import Vocabulary
import numpy as np
D = 32 # the dimensionality of the vectors
#Creating a vocabulary
rng = np.random.RandomState(0)
vocab = Vocabulary(dimensions=D, rng=rng)
vocab.add('C', vocab.parse('A * B'))
model = spa.SPA(label="structure", vocabs=[vocab])
with model:
model.A = spa.State(D)
model.B = spa.State(D)
model.C = spa.State(D, feedback=1)
model.Sum = spa.State(D)
actions = spa.Actions(
'C = A * B',
'Sum = A',
'Sum = B'
)
model.cortical = spa.Cortical(actions)
def generate(input_signal, alpha=1000.0):
beta = alpha / 4.0
# generate the Function Space
forces, _, goals = forcing_functions.load_folder(
'models/locomotion_trajectories',
rhythmic=True,
alpha=alpha,
beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
# store the weights for each movement
weights_a = [] # ankle
weights_k = [] # knee
weights_h = [] # hip
# NOTE: things are added to weights based on the order files are read
for ii in range(int(len(goals) / 6)):
forces = force_space[ii * 6:ii * 6 + 6]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_a.append(
np.hstack([
np.dot(fs.basis.T, forces[0]), # ankle 1
np.dot(fs.basis.T, forces[1])
])) # ankle 2
weights_h.append(
np.hstack([
np.dot(fs.basis.T, forces[2]), # hip 1
np.dot(fs.basis.T, forces[3])
])) # hip 2
weights_k.append(
np.hstack([
np.dot(fs.basis.T, forces[4]), # knee 1
np.dot(fs.basis.T, forces[5])
])) # knee 2
# Create our vocabularies
sps_labels = ['GALLOP', 'RUNNING', 'WALKING']
rng = np.random.RandomState(0)
dimensions = 50 # some arbitrary number
vocab_input = Vocabulary(dimensions=dimensions, rng=rng)
vocab_dmp_weights_a = Vocabulary(dimensions=fs.n_basis * 2, rng=rng)
vocab_dmp_weights_k = Vocabulary(dimensions=fs.n_basis * 2, rng=rng)
vocab_dmp_weights_h = Vocabulary(dimensions=fs.n_basis * 2, rng=rng)
for ii, (label, wa, wk,
wh) in enumerate(zip(sps_labels, weights_a, weights_k,
weights_h)):
vocab_input.parse(label) # randomly generate input vector
vocab_dmp_weights_a.add(label, wa)
vocab_dmp_weights_k.add(label, wk)
vocab_dmp_weights_h.add(label, wh)
net = spa.SPA()
net.config[nengo.Ensemble].neuron_type = nengo.LIFRate()
with net:
config = nengo.Config(nengo.Ensemble)
config[nengo.Ensemble].neuron_type = nengo.Direct()
with config:
# --------------------- Inputs --------------------------
# def input_func(t):
# return vocab_input.parse(input_signal).v
# net.input = nengo.Node(input_func)
net.input = spa.State(dimensions,
subdimensions=10,
vocab=vocab_input)
# ------------------- Point Attractors --------------------
zero = nengo.Node([0])
net.a1 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.a1.input[0], synapse=None)
net.a2 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.a1.input[0], synapse=None)
net.k1 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.k1.input[0], synapse=None)
net.k2 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.k2.input[0], synapse=None)
net.h1 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.h1.input[0], synapse=None)
net.h2 = point_attractor.generate(n_neurons=1000,
alpha=alpha,
beta=beta)
nengo.Connection(zero, net.h2.input[0], synapse=None)
# -------------------- Oscillators ----------------------
kick = nengo.Node(nengo.utils.functions.piecewise({
0: 1,
.05: 0
}),
label='kick')
osc = oscillator.generate(net, n_neurons=3000, speed=.01)
osc.label = 'oscillator'
nengo.Connection(kick, osc[0])
# ------------------- Forcing Functions --------------------
with config:
net.assoc_mem_a = spa.AssociativeMemory(
input_vocab=vocab_input,
output_vocab=vocab_dmp_weights_a,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_a.input)
net.assoc_mem_k = spa.AssociativeMemory(
input_vocab=vocab_input,
output_vocab=vocab_dmp_weights_k,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_k.input)
net.assoc_mem_h = spa.AssociativeMemory(
input_vocab=vocab_input,
output_vocab=vocab_dmp_weights_h,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_h.input)
# -------------------- Product for decoding -----------------------
product_a1 = nengo.Network('Product A1')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_a1)
product_a2 = nengo.Network('Product A2')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_a2)
product_h1 = nengo.Network('Product H1')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_h1)
product_h2 = nengo.Network('Product H2')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_h2)
product_k1 = nengo.Network('Product K1')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_k1)
product_k2 = nengo.Network('Product K2')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=product_k2)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis * fs.scale)
domain = np.linspace(-np.pi, np.pi, fs.basis.shape[0])
domain_cossin = np.array([np.cos(domain), np.sin(domain)]).T
for ff, product in zip([
net.assoc_mem_a.output[:fs.n_basis],
net.assoc_mem_a.output[fs.n_basis:],
net.assoc_mem_k.output[:fs.n_basis],
net.assoc_mem_k.output[fs.n_basis:],
net.assoc_mem_h.output[:fs.n_basis],
net.assoc_mem_h.output[fs.n_basis:]
], [
product_a1, product_a2, product_k1, product_k2, product_h1,
product_h2
]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of (x, y)
target_function = nengo.utils.connection.target_function(
domain_cossin, fs.basis[:, ii] * fs.scale / max_basis)
nengo.Connection(osc, product.B[ii], **target_function)
# multiply the value of each basis function at x by its weight
nengo.Connection(ff, product.A)
nengo.Connection(product_a1.output,
net.a1.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_a2.output,
net.a2.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_k1.output,
net.k1.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_k2.output,
net.k2.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_h1.output,
net.h1.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
nengo.Connection(product_h2.output,
net.h2.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=6, label='output')
nengo.Connection(net.a1.output, net.output[0], synapse=0.01)
nengo.Connection(net.a2.output, net.output[1], synapse=0.01)
nengo.Connection(net.k1.output, net.output[2], synapse=0.01)
nengo.Connection(net.k2.output, net.output[3], synapse=0.01)
nengo.Connection(net.h1.output, net.output[4], synapse=0.01)
nengo.Connection(net.h2.output, net.output[5], synapse=0.01)
# add in the goal offsets
nengo.Connection(net.assoc_mem_a.output[[-2, -1]],
net.output[[0, 1]],
synapse=None)
nengo.Connection(net.assoc_mem_k.output[[-2, -1]],
net.output[[2, 3]],
synapse=None)
nengo.Connection(net.assoc_mem_h.output[[-2, -1]],
net.output[[4, 5]],
synapse=None)
# create a node to give a plot of the represented function
ff_plot_a = fs.make_plot_node(domain=domain,
lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_a.output, ff_plot_a, synapse=0.1)
ff_plot_k = fs.make_plot_node(domain=domain,
lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_k.output, ff_plot_k, synapse=0.1)
ff_plot_h = fs.make_plot_node(domain=domain,
lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_h.output, ff_plot_h, synapse=0.1)
return net
def test_add():
v = Vocabulary(3)
v.add("A", [1, 2, 3])
v.add("B", [4, 5, 6])
v.add("C", [7, 8, 9])
assert np.allclose(v.vectors, [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
def main():
model = spa.SPA(label="Vector Storage")
with model:
# Dimensionality of each representation
num_dimensions = 2
sub_dimensions = 2
# Create the vocabulary
vocab = Vocabulary(num_dimensions, randomize=False)
# Form the inputs
stored_value_1 = [1] * num_dimensions
stored_value_1 = [
s / np.linalg.norm(stored_value_1) for s in stored_value_1
]
vocab.add("Stored_value_1", stored_value_1)
stored_value_2 = [(-1**i) for i in range(num_dimensions)]
stored_value_2 = [
s / np.linalg.norm(stored_value_2) for s in stored_value_2
]
vocab.add("Stored_value_2", stored_value_2)
def first_input(t):
if t < 10:
return "Stored_value_2"
else:
return "Stored_value_1"
def second_input(t):
if t < 5:
return "Stored_value_1"
else:
return "Stored_value_2"
# Buffers to store the input
model.buffer1 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True)
model.buffer2 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True)
# Probe to visualize the values stored in the buffers
buffer_1_probe = nengo.Probe(model.buffer1.state.output)
buffer_2_probe = nengo.Probe(model.buffer2.state.output)
# Connect up the inputs
model.input = spa.Input(buffer1=first_input)
model.input = spa.Input(buffer2=second_input)
# Buffer to store the output
model.buffer3 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True)
buffer_3_probe = nengo.Probe(model.buffer3.state.output)
# Control system
actions = spa.Actions(
'dot(buffer1, Stored_value_2) --> buffer3=Stored_value_2',
'dot(buffer1, Stored_value_1) --> buffer3=Stored_value_1+Stored_value_2'
)
model.bg = spa.BasalGanglia(actions)
model.thalamus = spa.Thalamus(model.bg)
# Start the simulator
sim = nengo.Simulator(model)
# Dynamic plotting
plt.ion() # Dynamic updating of plots
fig = plt.figure(figsize=(15, 8))
plt.show()
ax = fig.gca()
ax.set_title("Vector Storage")
while True:
sim.run(1) # Run for an additional 1 second
plt.clf() # Clear the figure
plt.plot(sim.trange(),
similarity(sim.data, buffer_1_probe, vocab),
label="Buffer 1 Value") # Plot the entire dataset so far
plt.plot(sim.trange(),
similarity(sim.data, buffer_2_probe, vocab),
label="Buffer 2 Value")
plt.plot(sim.trange(),
similarity(sim.data, buffer_3_probe, vocab),
label="Buffer 3 Value")
print sim.data[buffer_1_probe][-1]
print sim.data[buffer_2_probe][-1]
print sim.data[buffer_3_probe][-1]
plt.legend(vocab.keys * 3, loc=2)
plt.draw() # Re-draw
def setup_probes_generic(model):
with model:
model.config[nengo.Probe].synapse = Lowpass(0.005)
vocab_dict = {}
graph_list = []
anim_config = []
sub_vocab1 = enum_vocab.create_subset(['POS1*ONE', 'POS2*TWO',
'POS3*THR', 'POS4*FOR',
'POS5*FIV'])
sub_vocab2 = vocab.create_subset(['ADD'])
sub_vocab2.readonly = False
sub_vocab2.add('N_ADD', vocab.parse('~ADD'))
sub_vocab2.add('ADD*ADD', vocab.parse('ADD*ADD'))
sub_vocab2.add('ADD*ADD*ADD', vocab.parse('ADD*ADD*ADD'))
# sub_vocab2.add('ADD*ADD*ADD*ADD', vocab.parse('ADD*ADD*ADD*ADD'))
# sub_vocab2.add('ADD*ADD*ADD*ADD*ADD',
# vocab.parse('ADD*ADD*ADD*ADD*ADD'))
sub_vocab3 = vocab.create_subset([])
sub_vocab3.readonly = False
# sub_vocab3.add('N_POS1*ONE', vocab.parse('~(POS1*ONE)'))
# sub_vocab3.add('N_POS1*TWO', vocab.parse('~(POS1*TWO)'))
# sub_vocab3.add('N_POS1*THR', vocab.parse('~(POS1*THR)'))
# sub_vocab3.add('N_POS1*FOR', vocab.parse('~(POS1*FOR)'))
# sub_vocab3.add('N_POS1*FIV', vocab.parse('~(POS1*FIV)'))
sub_vocab3.add('ADD', vocab.parse('ADD'))
sub_vocab3.add('INC', vocab.parse('INC'))
vocab_seq_list = vocab.create_subset([])
vocab_seq_list.readonly = False
for sp_str in ['POS1*ONE', 'POS2*TWO', 'POS3*THR', 'POS4*FOR',
'POS5*FIV', 'POS6*SIX', 'POS7*SEV', 'POS8*EIG']:
vocab_seq_list.add(sp_str, vocab.parse(sp_str))
vocab_rpm = vocab.create_subset([])
vocab_rpm.readonly = False
for i in [1, 3, 8]:
sp_str = num_sp_strs[i]
vocab_rpm.add('A_(P1+P2+P3)*%s' % sp_str,
vocab.parse('POS1*%s+POS2*%s+POS3*%s' %
(sp_str, sp_str, sp_str)))
vocab_rpm.add('N_(P1+P2+P3)*%s' % sp_str,
vocab.parse('~(POS1*%s+POS2*%s+POS3*%s)' %
(sp_str, sp_str, sp_str)))
####
vocab_seq_list = vocab_rpm
if hasattr(model, 'stim'):
p0 = nengo.Probe(model.stim.output, synapse=None)
add_to_anim_config(anim_config, key='vis',
data_func_name='generic_single',
data_func_params={'data': p0},
plot_type_name='imshow',
plot_type_params={'shape': (28, 28)})
else:
p0 = 0
if hasattr(model, 'vis') and True:
pvs1 = nengo.Probe(model.vis.output)
pvs2 = nengo.Probe(model.vis.neg_attention)
pvs3 = nengo.Probe(model.vis.am_utilities)
pvs4 = nengo.Probe(model.vis.mb_output)
pvs5 = nengo.Probe(model.vis.vis_out)
# probes = gen_graph_list(['vis', p0, pvs1, pvs2, pvs3])
# vocab_dict[idstr(pvs1)] = vis_vocab
add_to_graph_list(graph_list, ['vis', p0, pvs1, pvs2, pvs3, 0,
'vis net', pvs4, pvs5])
add_to_vocab_dict(vocab_dict, {pvs1: vis_vocab})
# ############ FOR DEBUGGING VIS DETECT SYSTEM ########################
# if hasattr(model, 'vis') and True:
# pvsd1 = nengo.Probe(model.vis.detect_change_net.input_diff)
# pvsd2 = nengo.Probe(model.vis.detect_change_net.item_detect)
# pvsd3 = nengo.Probe(model.vis.detect_change_net.blank_detect)
# probes = gen_graph_list(['vis detect', p0, pvsd1, pvsd2, pvsd3])
# graph_list.extend(probes)
if hasattr(model, 'ps') and True:
pps1 = nengo.Probe(model.ps.task)
pps2 = nengo.Probe(model.ps.state)
pps3 = nengo.Probe(model.ps.dec)
pps4 = nengo.Probe(model.ps.ps_task_mb.mem1.output)
pps5 = nengo.Probe(model.ps.ps_task_mb.mem2.output)
pps6 = nengo.Probe(model.ps.ps_task_mb.mem1.input, synapse=None)
pps6b = nengo.Probe(model.ps.task_init.output)
pps7 = nengo.Probe(model.ps.ps_state_mb.mem1.output)
pps8 = nengo.Probe(model.ps.ps_state_mb.mem2.output)
pps9 = nengo.Probe(model.ps.ps_state_mb.mem1.input, synapse=None)
pps10 = nengo.Probe(model.ps.ps_dec_mb.mem1.output)
pps11 = nengo.Probe(model.ps.ps_dec_mb.mem2.output)
pps12 = nengo.Probe(model.ps.ps_dec_mb.mem1.input, synapse=None)
pps13 = nengo.Probe(model.ps.ps_task_mb.gate)
pps14 = nengo.Probe(model.ps.ps_state_mb.gate)
pps15 = nengo.Probe(model.ps.ps_dec_mb.gate)
# probes = gen_graph_list(['ps', p0, pps1, pps2, pps3, 0,
# 'ps_task', p0, pps1, pps6, pps4, pps5, pps6b, pps13, 0, # noqa
# 'ps_state', p0, pps2, pps9, pps7, pps8, pps14, 0, # noqa
# 'ps_dec', p0, pps3, pps12, pps10, pps11, pps15], # noqa
# [pps1, pps2, pps3, pps4, pps5, pps6])
# graph_list.extend(probes)
# vocab_dict[idstr(pps1)] = ps_task_vocab
# vocab_dict[idstr(pps2)] = ps_state_vocab
# vocab_dict[idstr(pps3)] = ps_dec_vocab
# vocab_dict[idstr(pps4)] = ps_task_vocab
# vocab_dict[idstr(pps5)] = ps_task_vocab
# vocab_dict[idstr(pps6)] = ps_task_vocab
# vocab_dict[idstr(pps7)] = ps_state_vocab
# vocab_dict[idstr(pps8)] = ps_state_vocab
# vocab_dict[idstr(pps9)] = ps_state_vocab
# vocab_dict[idstr(pps10)] = ps_dec_vocab
# vocab_dict[idstr(pps11)] = ps_dec_vocab
# vocab_dict[idstr(pps12)] = ps_dec_vocab
add_to_graph_list(graph_list,
['ps', p0, pps1, pps2, pps3, 0,
'ps_task', p0, pps1, pps6, pps4, pps5, pps6b, pps13, 0, # noqa
'ps_state', p0, pps2, pps9, pps7, pps8, pps14, 0, # noqa
'ps_dec', p0, pps3, pps12, pps10, pps11, pps15], # noqa
[pps1, pps2, pps3, pps4, pps5, pps6])
add_to_vocab_dict(vocab_dict, {pps1: ps_task_vocab,
pps2: ps_state_vocab,
pps3: ps_dec_vocab,
pps4: ps_task_vocab,
pps5: ps_task_vocab,
pps6: ps_task_vocab,
pps7: ps_state_vocab,
pps8: ps_state_vocab,
pps9: ps_state_vocab,
pps10: ps_dec_vocab,
pps11: ps_dec_vocab,
pps12: ps_dec_vocab})
if hasattr(model, 'enc') and True:
pen1 = nengo.Probe(model.enc.pos_inc.gate)
# pen2 = nengo.Probe(model.enc.pos_mb.gateX)
# pen3 = nengo.Probe(model.enc.pos_mb.gateN)
pen4 = nengo.Probe(model.enc.pos_inc.output)
# pen5 = nengo.Probe(model.enc.pos_mb.mem1.output)
# pen6 = nengo.Probe(model.enc.pos_mb.am.output)
pen6 = nengo.Probe(model.enc.pos_inc.reset)
pen7 = nengo.Probe(model.enc.pos_mb_acc.output)
pen7a = nengo.Probe(model.enc.pos_mb_acc.input)
pen8 = nengo.Probe(model.enc.pos_output)
# probes = gen_graph_list(['enc', p0, pen4, pen7, pen6, 0,
# 'enc gate', pen1, pen2, pen3],
# [pen4, pen7])
# graph_list.extend(probes)
# vocab_dict[idstr(pen4)] = pos_vocab
# vocab_dict[idstr(pen7)] = pos_vocab
add_to_graph_list(graph_list,
['enc', p0, pen1, pen4, pen7, pen7a, pen6],
[pen4])
add_to_vocab_dict(vocab_dict, {pen4: pos_vocab,
pen7: pos_vocab,
pen7a: pos_vocab,
pen8: pos_vocab})
if hasattr(model, 'mem') and True:
pmm1 = nengo.Probe(model.mem.mb1)
pmm1a = nengo.Probe(model.mem.mb1_net.mb_reh)
pmm1b = nengo.Probe(model.mem.mb1_net.mb_dcy)
pmm2 = nengo.Probe(model.mem.mb1_net.gate)
pmm3 = nengo.Probe(model.mem.mb1_net.reset)
pmm4 = nengo.Probe(model.mem.mb2)
pmm5 = nengo.Probe(model.mem.mb2_net.gate)
pmm6 = nengo.Probe(model.mem.mb2_net.reset)
pmm7 = nengo.Probe(model.mem.mb3)
pmm8 = nengo.Probe(model.mem.mb3_net.gate)
pmm9 = nengo.Probe(model.mem.mb3_net.reset)
# probes = gen_graph_list(['mb1', p0, pmm1, pmm2, pmm3, 0,
# 'mb2', p0, pmm4, pmm5, pmm6, 0,
# 'mb3', p0, pmm7, pmm8, pmm9],
# [pmm1, pmm4, pmm7])
# graph_list.extend(probes)
# vocab_dict[idstr(pmm1)] = sub_vocab1
# vocab_dict[idstr(pmm4)] = sub_vocab1
# vocab_dict[idstr(pmm7)] = sub_vocab1
# add_to_graph_list(graph_list,
# ['mb1', p0, pmm1, pmm2, pmm3, 0,
# 'mb2', p0, pmm4, pmm5, pmm6, 0,
# 'mb3', p0, pmm7, pmm8, pmm9],
# [pmm1, pmm4, pmm7])
add_to_graph_list(graph_list,
['mb1', p0, pmm1, pmm1a, pmm1b, pmm2, pmm3, 0,
'mb2', p0, pmm4, pmm5, pmm6, 0,
'mb3', p0, pmm7, pmm8, pmm9])
add_to_vocab_dict(vocab_dict, {pmm1: vocab_seq_list,
pmm1a: vocab_seq_list,
pmm1b: vocab_seq_list,
pmm4: vocab_seq_list,
pmm7: vocab_seq_list})
if hasattr(model, 'mem') and True:
pmm10 = nengo.Probe(model.mem.mbave_net.input)
pmm11 = nengo.Probe(model.mem.mbave_net.gate)
pmm12 = nengo.Probe(model.mem.mbave_net.reset)
pmm13 = nengo.Probe(model.mem.mbave)
# pmm14 = nengo.Probe(model.mem.mbave_norm.output)
# pmm15 = nengo.Probe(model.mem.mbave_in_init.output)
# probes = gen_graph_list(['mbave', p0, pmm10, pmm11, pmm12, pmm13,
# pmm15, pmm14],
# pmm10)
# graph_list.extend(probes)
# vocab_dict[idstr(pmm10)] = sub_vocab2
# vocab_dict[idstr(pmm13)] = sub_vocab2
# vocab_dict[idstr(pmm15)] = sub_vocab2
add_to_graph_list(graph_list,
['mbave', p0, pmm10, pmm11, pmm12, pmm13],
[pmm10])
add_to_vocab_dict(vocab_dict, {pmm10: sub_vocab2,
pmm13: sub_vocab3})
# if (hasattr(model, 'mem') and not isinstance(model.mem,
# WorkingMemoryDummy)):
# mem = model.mem.mb3a
# pmm11 = nengo.Probe(mem.gateX)
# pmm12 = nengo.Probe(mem.gateN)
# pmm13 = nengo.Probe(mem.gate)
# pmm14 = nengo.Probe(mem.reset)
# pmm15 = nengo.Probe(model.mem.gate_sig_bias.output)
# pmm16 = nengo.Probe(mem.input)
# probes = gen_graph_list(['mb3a sigs', p0, pmm11, pmm12, pmm13,
# pmm14, pmm15, pmm16],
# [pmm16])
# graph_list.extend(probes)
# vocab_dict[idstr(pmm16)] = sub_vocab1
if hasattr(model, 'trfm') and \
not isinstance(model.trfm, TransformationSystemDummy):
ptf1 = nengo.Probe(model.trfm.select_in_a.output)
ptf2 = nengo.Probe(model.trfm.select_in_b.output)
ptf3 = nengo.Probe(model.trfm.cconv1.output)
ptf3b = nengo.Probe(model.trfm.cconv1.output)
ptf3c = nengo.Probe(model.trfm.cconv1.output)
ptf3d = nengo.Probe(model.trfm.cconv1.output)
ptf4 = nengo.Probe(model.trfm.output)
ptf4b = nengo.Probe(model.trfm.output)
ptf5 = nengo.Probe(model.trfm.compare.output)
ptf6 = nengo.Probe(model.trfm.norm_a.output)
ptf7 = nengo.Probe(model.trfm.norm_b.output)
ptf8 = nengo.Probe(model.trfm.norm_a.input)
ptf9 = nengo.Probe(model.trfm.norm_b.input)
ptf10 = nengo.Probe(model.trfm.compare.dot_prod)
ptf11a = nengo.Probe(model.trfm.cconv1.A)
ptf11b = nengo.Probe(model.trfm.cconv1.B)
# probes = gen_graph_list(['trfm io', p0, ptf1, ptf2, ptf4, ptf4b, 0,
# 'trfm cc', p0, ptf3, ptf3b, ptf3c, ptf3d, 0, # noqa
# 'trfm cmp', ptf5, ptf8, ptf6, ptf9, ptf7,
# ptf10],
# [ptf1, ptf2, ptf3, ptf3b, ptf3c, ptf4,
# ptf4b, ptf6, ptf7])
# graph_list.extend(probes)
# vocab_dict[idstr(ptf1)] = sub_vocab1
# vocab_dict[idstr(ptf2)] = sub_vocab3
# vocab_dict[idstr(ptf3)] = item_vocab
# vocab_dict[idstr(ptf3b)] = pos_vocab
# vocab_dict[idstr(ptf3c)] = sub_vocab2
# vocab_dict[idstr(ptf3d)] = sub_vocab1
# vocab_dict[idstr(ptf4)] = sub_vocab2
# vocab_dict[idstr(ptf4b)] = sub_vocab1
# vocab_dict[idstr(ptf5)] = ps_cmp_vocab
# vocab_dict[idstr(ptf6)] = sub_vocab1
# vocab_dict[idstr(ptf7)] = sub_vocab1
# vocab_dict[idstr(ptf8)] = sub_vocab1
# vocab_dict[idstr(ptf9)] = sub_vocab1
add_to_graph_list(graph_list,
['trfm io', p0, ptf1, ptf2, ptf4, 0,
'trfm cc', p0, pmm11, ptf3, ptf11a, ptf11b, pmm13, 0, # noqa
'trfm cmp', ptf5, ptf8, ptf6, ptf9, ptf7, ptf10], # noqa
[ptf1, ptf4, ptf6, ptf7])
# add_to_vocab_dict(vocab_dict, {ptf1: sub_vocab1,
# ptf2: sub_vocab3,
# ptf3: item_vocab,
# ptf3b: pos_vocab,
# ptf3c: sub_vocab2,
# ptf3d: sub_vocab1,
# ptf4: sub_vocab2,
# ptf4b: sub_vocab1,
# ptf5: ps_cmp_vocab,
# ptf6: sub_vocab1,
# ptf7: sub_vocab1,
# ptf8: sub_vocab1,
# ptf9: sub_vocab1})
add_to_vocab_dict(vocab_dict, {ptf1: vocab_rpm,
ptf2: vocab_rpm,
ptf3: vocab_rpm,
ptf4: vocab_rpm,
ptf5: ps_cmp_vocab,
ptf6: sub_vocab1,
ptf7: sub_vocab1,
ptf8: sub_vocab1,
ptf9: sub_vocab1,
ptf11a: vocab_rpm,
ptf11b: vocab_rpm})
if hasattr(model, 'trfm') and \
not isinstance(model.trfm, TransformationSystemDummy):
ptf5 = nengo.Probe(model.trfm.am_trfms.pos1_to_pos)
ptf6 = nengo.Probe(model.trfm.am_trfms.pos1_to_num)
ptf7 = nengo.Probe(model.trfm.am_trfms.num_to_pos1)
ptf8 = nengo.Probe(model.trfm.am_trfms.pos_to_pos1)
# ptf9 = nengo.Probe(model.trfm.vis_trfm_utils)
# ptf10 = nengo.Probe(model.trfm.vis_trfm_in)
# probes = gen_graph_list(['trfm am1', p0, ptf5, ptf6, 0,
# 'trfm am2', p0, ptf7, ptf8],
# [ptf5, ptf6, ptf7, ptf8])
# graph_list.extend(probes)
# vocab_dict[idstr(ptf5)] = pos_vocab
# vocab_dict[idstr(ptf6)] = item_vocab
# vocab_dict[idstr(ptf7)] = pos1_vocab
# vocab_dict[idstr(ptf8)] = pos1_vocab
add_to_graph_list(graph_list,
['trfm am1', p0, ptf5, ptf6, 0,
'trfm am2', p0, ptf7, ptf8, 0],
# 'trfm vis', p0, ptf9, ptf10],
[ptf5, ptf6, ptf7, ptf8])
add_to_vocab_dict(vocab_dict, {ptf5: pos_vocab,
ptf6: item_vocab,
ptf7: pos1_vocab,
ptf8: pos1_vocab})
if hasattr(model, 'bg') and True:
pbg1 = nengo.Probe(model.bg.input)
pbg2 = nengo.Probe(model.bg.output)
# probes = gen_graph_list(['bg', p0, pbg1, pbg2])
# graph_list.extend(probes)
add_to_graph_list(graph_list, ['bg', p0, pbg1, pbg2])
if hasattr(model, 'dec') and True:
pde1 = nengo.Probe(model.dec.item_dcconv)
# pde2 = nengo.Probe(model.dec.select_am)
# pde3 = nengo.Probe(model.dec.select_vis)
pde4 = nengo.Probe(model.dec.am_out, synapse=0.01)
# pde5 = nengo.Probe(model.dec.vt_out)
pde6 = nengo.Probe(model.dec.pos_mb_gate_sig.output)
# pde7 = nengo.Probe(model.dec.util_diff_neg)
pde8 = nengo.Probe(model.dec.am_utils)
pde9 = nengo.Probe(model.dec.am2_utils)
pde10 = nengo.Probe(model.dec.util_diff)
pde11 = nengo.Probe(model.dec.pos_recall_mb)
pde11a = nengo.Probe(model.dec.pos_recall_mb_in)
pde11b = nengo.Probe(model.dec.fr_recall_mb.gate)
pde11c = nengo.Probe(model.dec.fr_recall_mb.reset)
pde11d = nengo.Probe(model.dec.fr_recall_mb.mem1.input)
pde11e = nengo.Probe(model.dec.fr_recall_mb.mem2.input)
# pde12 = nengo.Probe(model.dec.recall_mb.gateX)
# pde13 = nengo.Probe(model.dec.recall_mb.gateN)
# pde14a = nengo.Probe(model.dec.recall_mb.mem1.input)
# pde14b = nengo.Probe(model.dec.recall_mb.mem1.output)
# pde14c = nengo.Probe(model.dec.recall_mb.mem2.input)
# pde14d = nengo.Probe(model.dec.recall_mb.mem2.output)
# pde14e = nengo.Probe(model.dec.recall_mb.mem1.diff.output)
# pde14f = nengo.Probe(model.dec.recall_mb.reset)
# pde14g = nengo.Probe(model.dec.recall_mb.mem1.gate)
# pde12 = nengo.Probe(model.dec.dec_am_fr.output)
# pde13 = nengo.Probe(model.dec.dec_am.item_output)
# pde14 = nengo.Probe(model.dec.recall_mb.mem1.output)
pde15 = nengo.Probe(model.dec.output_know)
pde16 = nengo.Probe(model.dec.output_unk)
pde18 = nengo.Probe(model.dec.output_stop)
# pde19 = nengo.Probe(model.dec.am_th_utils)
# pde20 = nengo.Probe(model.dec.fr_th_utils)
pde21 = nengo.Probe(model.dec.output)
# pde22 = nengo.Probe(model.dec.dec_am_fr.input)
# pde23 = nengo.Probe(model.dec.am_def_th_utils)
# pde24 = nengo.Probe(model.dec.fr_def_th_utils)
pde25 = nengo.Probe(model.dec.fr_utils)
pde26 = nengo.Probe(model.dec.pos_mb_gate_bias.output)
pde27 = nengo.Probe(model.dec.pos_acc_input)
pde28 = nengo.Probe(model.dec.item_dcconv_a)
pde29 = nengo.Probe(model.dec.item_dcconv_b)
pde30 = nengo.Probe(model.dec.sel_signals)
pde31 = nengo.Probe(model.dec.select_out.input0)
pde32 = nengo.Probe(model.dec.select_out.input1)
pde33 = nengo.Probe(model.dec.select_out.input3)
pde34 = nengo.Probe(model.dec.out_class_sr_y)
pde35 = nengo.Probe(model.dec.out_class_sr_diff)
pde36 = nengo.Probe(model.dec.out_class_sr_n)
sel_out_vocab = Vocabulary(5)
for n in range(5):
vec = np.zeros(5)
vec[n] = 1
sel_out_vocab.add('SEL%d' % n, vec)
# probes = gen_graph_list(['dec decconv', pde1, pde4, pde21, 0,
# 'dec kn unk st', pde15, pde16, pde18, 0,
# 'dec am utils', pde8, pde9, pde25, 0,
# 'dec sigs', pde6, pde26, pde11, pde27],
# [pde21])
# # 'dec mb sigs', pde12, pde13, pde14f, pde14g, pde14a, pde14e, pde14b, pde14c, pde14d], # noqa
# graph_list.extend(probes)
# vocab_dict[idstr(pde1)] = item_vocab
# vocab_dict[idstr(pde4)] = mtr_vocab
# vocab_dict[idstr(pde21)] = mtr_vocab
# vocab_dict[idstr(pde11)] = pos_vocab
# vocab_dict[idstr(pde27)] = pos_vocab
# # vocab_dict[idstr(pde14a)] = pos_vocab
# # vocab_dict[idstr(pde14b)] = pos_vocab
# # vocab_dict[idstr(pde14c)] = pos_vocab
# # vocab_dict[idstr(pde14d)] = pos_vocab
add_to_graph_list(graph_list,
['dec decconv', pde28, pde29, pde1, pde4, pde21, 0,
'dec kn unk st', pde15, pde16, pde18, 0,
'dec am utils', pde8, pde9, pde10, pde25, 0,
'dec sigs', pde6, pde26, pde11, pde27, 0,
'dec fr', pde11b, pde11c, pde11, pde11a, pde11d, pde11e, 0,
'dec sel', pde30, pde31, pde32, pde33, 0,
'dec out class', pde34, pde35, pde36],
[pde21, pde30])
add_to_vocab_dict(vocab_dict, {pde1: item_vocab,
pde4: mtr_vocab,
pde21: mtr_vocab,
pde11: pos_vocab,
pde11a: pos_vocab,
pde11d: pos_vocab,
pde11e: pos_vocab,
pde27: pos_vocab,
pde28: sub_vocab2,
pde29: pos_vocab,
pde30: sel_out_vocab,
pde31: mtr_disp_vocab,
pde32: mtr_disp_vocab,
pde33: mtr_disp_vocab})
if hasattr(model, 'mtr'):
pmt1 = nengo.Probe(model.mtr.ramp)
pmt2 = nengo.Probe(model.mtr.ramp_reset_hold)
pmt3 = nengo.Probe(model.mtr.motor_stop_input.output)
pmt4 = nengo.Probe(model.mtr.motor_init.output)
pmt5 = nengo.Probe(model.mtr.motor_go)
pmt6 = nengo.Probe(model.mtr.ramp_sig.stop)
# pmt6 = nengo.Probe(model.mtr.ramp_int_stop)
pmt7a = nengo.Probe(model.mtr.arm_px_node)
pmt7b = nengo.Probe(model.mtr.arm_py_node)
pmt8 = nengo.Probe(model.mtr.pen_down)
pmt9 = nengo.Probe(model.mtr.zero_centered_arm_ee_loc,
synapse=0.01)
pmt10 = nengo.Probe(model.mtr.zero_centered_tgt_ee_loc,
synapse=0.03)
pmt11 = nengo.Probe(model.mtr.motor_bypass.output)
add_to_graph_list(graph_list,
['mtr', p0, pmt1, pmt2, pmt6, pmt3, pmt4, pmt5, pmt11, 0, # noqa
'arm', pmt7a, pmt7b, pmt8])
add_to_anim_config(anim_config, key='mtr',
data_func_name='arm_path',
data_func_params={'ee_path_data': pmt9,
'target_path_data': pmt10,
'pen_status_data': pmt8},
# 'arm_posx_data': pmt7a,
# 'arm_posy_data': pmt7b,
# 'arm_pos_bias': [cfg.mtr_arm_rest_x_bias, cfg.mtr_arm_rest_y_bias]}, # noqa
plot_type_name='arm_path_plot',
plot_type_params={'show_tick_labels': True,
'xlim': (-mtr_sp_scale_factor, mtr_sp_scale_factor), # noqa
'ylim': (-mtr_sp_scale_factor, mtr_sp_scale_factor)}) # noqa
# --------------------- ANIMATION CONFIGURATION -----------------------
anim_config.append({'subplot_width': 5,
'subplot_height': 5,
'max_subplot_cols': 4,
'generator_func_params': {'t_index_step': 10}})
return (graph_list[:-1], vocab_dict, anim_config)
def generate(input_signal, alpha=1000.0):
beta = alpha / 4.0
# Read in the class mean for numbers from vision network
weights_data = np.load('models/mnist_vision_data/params.npz')
weights = weights_data['Wc']
means_data = np.load('models/mnist_vision_data/class_means.npz')
means = np.matrix(1.0 / means_data['means'])
sps = np.multiply(weights.T, means.T)[:10]
sps_labels = [
'ZERO', 'ONE', 'TWO', 'THREE', 'FOUR',
'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE']
dimensions = weights.shape[0]
# generate the Function Space
forces, _, _ = forcing_functions.load_folder(
'models/handwriting_trajectories', rhythmic=True,
alpha=alpha, beta=beta)
# make an array out of all the possible functions we want to represent
force_space = np.vstack(forces)
# use this array as our space to perform svd over
fs = nengo.FunctionSpace(space=force_space, n_basis=10)
# store the weights for each trajectory
weights_x = []
weights_y = []
for ii in range(len(forces)):
forces = force_space[ii*2:ii*2+2]
# load up the forces to be output by the forcing function
# calculate the corresponding weights over the basis functions
weights_x.append(np.dot(fs.basis.T, forces[0]))
weights_y.append(np.dot(fs.basis.T, forces[1]))
# Create our vocabularies
rng = np.random.RandomState(0)
vocab_vision = Vocabulary(dimensions=dimensions, rng=rng)
vocab_dmp_weights_x = Vocabulary(dimensions=fs.n_basis, rng=rng)
vocab_dmp_weights_y = Vocabulary(dimensions=fs.n_basis, rng=rng)
for label, sp, wx, wy in zip(
sps_labels, sps, weights_x, weights_y):
vocab_vision.add(
label, np.array(sp)[0] / np.linalg.norm(np.array(sp)[0]))
vocab_dmp_weights_x.add(label, wx)
vocab_dmp_weights_y.add(label, wy)
net = spa.SPA()
# net.config[nengo.Ensemble].neuron_type = nengo.Direct()
with net:
# --------------------- Inputs --------------------------
# def input_func(t):
# return vocab_vision.parse(input_signal).v
# net.input = nengo.Node(input_func, label='input')
net.input = spa.State(dimensions, subdimensions=10,
vocab=vocab_vision)
number = nengo.Node(output=[0], label='number')
# ------------------- Point Attractors --------------------
net.x = point_attractor.generate(
n_neurons=1000, alpha=alpha, beta=beta)
net.y = point_attractor.generate(
n_neurons=1000, alpha=alpha, beta=beta)
# -------------------- Oscillators ----------------------
kick = nengo.Node(nengo.utils.functions.piecewise({0: 1, .05: 0}),
label='kick')
osc = oscillator.generate(net, n_neurons=2000, speed=.05)
osc.label = 'oscillator'
nengo.Connection(kick, osc[0])
# ------------------- Forcing Functions --------------------
net.assoc_mem_x = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_x,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_x.input)
net.assoc_mem_y = spa.AssociativeMemory(
input_vocab=vocab_vision,
output_vocab=vocab_dmp_weights_y,
wta_output=False)
nengo.Connection(net.input.output, net.assoc_mem_y.input)
# -------------------- Product for decoding -----------------------
net.product_x = nengo.Network('Product X')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_x,
input_magnitude=1.0)
net.product_y = nengo.Network('Product Y')
nengo.networks.Product(n_neurons=1000,
dimensions=fs.n_basis,
net=net.product_y,
input_magnitude=1.0)
# get the largest basis function value for normalization
max_basis = np.max(fs.basis*fs.scale)
domain = np.linspace(-np.pi, np.pi, fs.basis.shape[0])
domain_cossin = np.array([np.cos(domain), np.sin(domain)]).T
for ff, product in zip([net.assoc_mem_x.output,
net.assoc_mem_y.output],
[net.product_x, net.product_y]):
for ii in range(fs.n_basis):
# find the value of a basis function at a value of (x, y)
target_function = nengo.utils.connection.target_function(
domain_cossin, fs.basis[:, ii]*fs.scale/max_basis)
nengo.Connection(osc, product.B[ii], **target_function)
# multiply the value of each basis function at x by its weight
nengo.Connection(ff, product.A)
nengo.Connection(net.product_x.output, net.x.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
nengo.Connection(net.product_y.output, net.y.input[1],
transform=np.ones((1, fs.n_basis)) * max_basis,
synapse=None)
# -------------------- Output ------------------------------
net.output = nengo.Node(size_in=2, label='output')
nengo.Connection(net.x.output, net.output[0])
nengo.Connection(net.y.output, net.output[1])
# create a node to give a plot of the represented function
ff_plot = fs.make_plot_node(domain=domain, lines=2,
ylim=[-1000000, 1000000])
nengo.Connection(net.assoc_mem_x.output,
ff_plot[:fs.n_basis], synapse=0.1)
nengo.Connection(net.assoc_mem_y.output,
ff_plot[fs.n_basis:], synapse=0.1)
return net
def test_add(rng):
v = Vocabulary(3, rng=rng)
v.add('A', [1, 2, 3])
v.add('B', [4, 5, 6])
v.add('C', [7, 8, 9])
assert np.allclose(v.vectors, [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
def initialize_probes(self):
# ===================== MAKE DISPLAY VOCABS ===========================
sub_vocab1 = self.v.enum.create_subset(
['POS1*ONE', 'POS2*TWO', 'POS3*THR', 'POS4*FOR', 'POS5*FIV'])
sub_vocab2 = self.v.main.create_subset(['ADD'])
sub_vocab2.readonly = False
sub_vocab2.add('N_ADD', self.v.main.parse('~ADD'))
sub_vocab2.add('ADD*ADD', self.v.main.parse('ADD*ADD'))
sub_vocab2.add('ADD*ADD*ADD', self.v.main.parse('ADD*ADD*ADD'))
# sub_vocab2.add('ADD*ADD*ADD*ADD',
# self.v.main.parse('ADD*ADD*ADD*ADD'))
# sub_vocab2.add('ADD*ADD*ADD*ADD*ADD',
# self.v.main.parse('ADD*ADD*ADD*ADD*ADD'))
sub_vocab3 = self.v.main.create_subset([])
sub_vocab3.readonly = False
# sub_vocab3.add('N_POS1*ONE', self.v.main.parse('~(POS1*ONE)'))
# sub_vocab3.add('N_POS1*TWO', self.v.main.parse('~(POS1*TWO)'))
# sub_vocab3.add('N_POS1*THR', self.v.main.parse('~(POS1*THR)'))
# sub_vocab3.add('N_POS1*FOR', self.v.main.parse('~(POS1*FOR)'))
# sub_vocab3.add('N_POS1*FIV', self.v.main.parse('~(POS1*FIV)'))
sub_vocab3.add('ADD', self.v.main.parse('ADD'))
sub_vocab3.add('INC', self.v.main.parse('INC'))
vocab_seq_list = self.v.main.create_subset([])
vocab_seq_list.readonly = False
for sp_str in [
'POS1*ONE', 'POS2*TWO', 'POS3*THR', 'POS4*FOR', 'POS5*FIV',
'POS6*SIX', 'POS7*SEV', 'POS8*EIG'
]:
vocab_seq_list.add(sp_str, self.v.main.parse(sp_str))
vocab_rpm = self.v.main.create_subset([])
vocab_rpm.readonly = False
for i in [1, 3, 8]:
sp_str = self.v.num_sp_strs[i]
vocab_rpm.add(
'A_(P1+P2+P3)*%s' % sp_str,
self.v.main.parse('POS1*%s+POS2*%s+POS3*%s' %
(sp_str, sp_str, sp_str)))
vocab_rpm.add(
'N_(P1+P2+P3)*%s' % sp_str,
self.v.main.parse('~(POS1*%s+POS2*%s+POS3*%s)' %
(sp_str, sp_str, sp_str)))
vocab_pos1 = self.v.main.create_subset([])
vocab_pos1.readonly = False
for sp_str in self.v.num_sp_strs:
p1_str = 'POS1*%s' % sp_str
vocab_pos1.add(p1_str, self.v.main.parse(p1_str))
# ----------- Default vocabs ------------------
mem_vocab = vocab_seq_list
# mem_vocab = vocab_pos1
# vocab_seq_list = vocab_rpm
# ========================= MAKE PROBES ===============================
if hasattr(self.m, 'stim'):
p0 = self.probe_image(self.m.stim.output,
synapse=None,
shape=(28, 28))
else:
with self.m:
self.m.null_node = nengo.Node(0)
p0 = self.probe_value(self.m.null_node)
if hasattr(self.m, 'vis') and True:
net = self.m.vis
pvs1 = self.probe_value(net.output, vocab=self.v.vis_main)
pvs2 = self.probe_value(net.neg_attention)
pvs3 = self.probe_value(net.am_utilities)
pvs4 = self.probe_value(net.mb_output)
pvs5 = self.probe_value(net.vis_out)
self.add_graph('vis', [p0, pvs1, pvs2, pvs3])
self.add_graph('vis net', [pvs4, pvs5])
# ############ FOR DEBUGGING VIS DETECT SYSTEM ########################
# if hasattr(self.m, 'vis') and True:
# net = self.m.vis
# pvsd1 = self.probe_value(net.detect_change_net.input_diff)
# pvsd2 = self.probe_value(net.detect_change_net.item_detect)
# pvsd3 = self.probe_value(net.detect_change_net.blank_detect)
#
# self.add_graph('vis detect', [p0, pvsd1, pvsd2, pvsd3])
if hasattr(self.m, 'ps') and True:
net = self.m.ps
pps1 = self.probe_value(net.task, vocab=self.v.ps_task)
pps2 = self.probe_value(net.state, vocab=self.v.ps_state)
pps3 = self.probe_value(net.dec, vocab=self.v.ps_dec)
pps4 = self.probe_value(net.task_mb.mem1.output,
vocab=self.v.ps_task)
pps5 = self.probe_value(net.task_mb.mem2.output,
vocab=self.v.ps_task)
pps6 = self.probe_value(net.task_mb.mem1.input,
synapse=None,
vocab=self.v.ps_task)
pps6b = self.probe_value(net.task_init.output)
pps7 = self.probe_value(net.state_mb.mem1.output,
vocab=self.v.ps_state)
pps8 = self.probe_value(net.state_mb.mem2.output,
vocab=self.v.ps_state)
pps9 = self.probe_value(net.state_mb.mem1.input,
synapse=None,
vocab=self.v.ps_state)
pps10 = self.probe_value(net.dec_mb.mem1.output,
vocab=self.v.ps_dec)
pps11 = self.probe_value(net.dec_mb.mem2.output,
vocab=self.v.ps_dec)
pps12 = self.probe_value(net.dec_mb.mem1.input,
synapse=None,
vocab=self.v.ps_dec)
pps13 = self.probe_value(net.task_mb.gate)
pps14 = self.probe_value(net.state_mb.gate)
pps15 = self.probe_value(net.dec_mb.gate)
pps13b = self.probe_value(net.task_mb.mem1.gate)
pps14b = self.probe_value(net.state_mb.mem1.gate)
pps15b = self.probe_value(net.dec_mb.mem1.gate)
pps13r = self.probe_value(net.task_mb.reset)
pps14r = self.probe_value(net.state_mb.reset)
pps15r = self.probe_value(net.dec_mb.reset)
pps16 = self.probe_value(net.action, vocab=self.v.ps_action_learn)
pps17 = self.probe_value(net.action_in,
vocab=self.v.ps_action_learn)
self.add_graph('ps', [p0, pps1, pps2, pps3], [pps1, pps2, pps3])
self.add_graph(
'ps_task',
[p0, pps6, pps4, pps5, pps6b, pps13, pps13b, pps13r],
[pps4, pps5, pps6])
self.add_graph('ps_state',
[p0, pps9, pps7, pps8, pps14, pps14b, pps14r])
self.add_graph('ps_dec',
[p0, pps12, pps10, pps11, pps15, pps15b, pps15r])
self.add_graph('ps_action', [p0, pps17, pps16], [pps16])
if hasattr(self.m, 'enc') and True:
net = self.m.enc
pen1 = self.probe_value(net.pos_inc.gate)
pen2 = self.probe_value(net.pos_inc.pos_mb.gateX)
pen4 = self.probe_value(net.pos_inc.output, vocab=self.v.pos)
pen5 = self.probe_value(net.pos_inc.pos_mb.mem1.output,
vocab=self.v.pos)
pen5b = self.probe_value(net.pos_inc.pos_mb.mem2.output,
vocab=self.v.pos)
pen6 = self.probe_value(net.pos_inc.reset)
# pen7 = self.probe_value(net.pos_mb_acc.output, vocab=self.v.pos)
# pen7a = self.probe_value(net.pos_mb_acc.input, vocab=self.v.pos)
# pen8 = self.probe_value(net.pos_output, vocab=self.v.pos)
self.add_graph('enc', [p0, pen1, pen2, pen4, pen5, pen5b, pen6],
[pen4])
if hasattr(self.m, 'mem') and True:
net = self.m.mem
pmm1 = self.probe_value(net.mb1, vocab=mem_vocab)
pmm1a = self.probe_value(net.mb1_net.mb_reh, vocab=mem_vocab)
pmm1b = self.probe_value(net.mb1_net.mb_dcy, vocab=mem_vocab)
pmm2 = self.probe_value(net.mb1_net.gate)
pmm3 = self.probe_value(net.mb1_net.reset)
pmm4 = self.probe_value(net.mb2, vocab=vocab_seq_list)
pmm5 = self.probe_value(net.mb2_net.gate)
pmm6 = self.probe_value(net.mb2_net.reset)
pmm7 = self.probe_value(net.mb3, vocab=vocab_seq_list)
pmm8 = self.probe_value(net.mb3_net.gate)
pmm9 = self.probe_value(net.mb3_net.reset)
self.add_graph('mb1', [p0, pmm1, pmm1a, pmm1b, pmm2, pmm3])
self.add_graph('mb2', [p0, pmm4, pmm5, pmm6])
self.add_graph('mb3', [p0, pmm7, pmm8, pmm9])
if hasattr(self.m, 'mem') and True:
net = self.m.mem
pmm1i = self.probe_value(net.input, vocab=mem_vocab)
pmm1ai = self.probe_value(net.mb1_net.mba.mem1.input,
vocab=mem_vocab)
pmm1bi = self.probe_value(net.mb1_net.mba.mem2.input,
vocab=mem_vocab)
pmm1g = self.probe_value(net.mb1_net.gate)
pmm1gx = self.probe_value(net.mb1_net.mba.gateX)
pmm1gn = self.probe_value(net.mb1_net.mba.gateN)
pmm1ag = self.probe_value(net.mb1_net.mba.mem1.gate)
pmm1bg = self.probe_value(net.mb1_net.mba.mem2.gate)
self.add_graph('mb1 details', [
pmm1i, pmm1ai, pmm1bi, pmm1a, pmm1g, pmm1gx, pmm1gn, pmm1ag,
pmm1bg
])
if hasattr(self.m, 'mem') and True:
net = self.m.mem
pmm10 = self.probe_value(net.mbave_net.input, vocab=sub_vocab2)
pmm11 = self.probe_value(net.mbave_net.gate)
pmm12 = self.probe_value(net.mbave_net.reset)
pmm13 = self.probe_value(net.mbave, vocab=sub_vocab2)
pmm13a = self.probe_value(net.mbave)
self.add_graph('mbave', [p0, pmm10, pmm11, pmm12, pmm13, pmm13a],
[pmm10])
if hasattr(self.m, 'trfm') and \
not isinstance(self.m.trfm, TransformationSystemDummy):
net = self.m.trfm
ptf1 = self.probe_value(net.select_in_a.output, vocab=mem_vocab)
ptf2 = self.probe_value(net.select_in_b.output, vocab=mem_vocab)
ptf3 = self.probe_value(net.cconv1.output, vocab=vocab_rpm)
ptf3b = self.probe_value(ptf3)
# ptf3c = self.probe_value(ptf3)
# ptf3d = self.probe_value(ptf3)
ptf4 = self.probe_value(net.output, vocab=mem_vocab)
# ptf4b = self.probe_value(net.output)
ptf5 = self.probe_value(net.compare.output, vocab=self.v.ps_cmp)
ptf6 = self.probe_value(net.norm_a.output, vocab=sub_vocab1)
ptf7 = self.probe_value(net.norm_b.output, vocab=sub_vocab1)
ptf8 = self.probe_value(net.norm_a.input, vocab=sub_vocab1)
ptf9 = self.probe_value(net.norm_b.input, vocab=sub_vocab1)
ptf10 = self.probe_value(net.compare.dot_prod)
ptf11a = self.probe_value(net.cconv1.A, vocab=vocab_rpm)
ptf11b = self.probe_value(net.cconv1.B, vocab=vocab_rpm)
self.add_graph('trfm io', [p0, ptf1, ptf2, ptf4], [ptf1, ptf4])
self.add_graph('trfm cc', [p0, pmm11, ptf3, ptf3b, ptf11a, ptf11b])
self.add_graph('trfm cmp', [ptf5, ptf8, ptf6, ptf9, ptf7, ptf10],
[ptf6, ptf7])
if hasattr(self.m, 'trfm') and \
not isinstance(self.m.trfm, TransformationSystemDummy):
nt = self.m.trfm
ptf5 = self.probe_value(nt.am_trfms.pos1_to_pos, vocab=self.v.pos)
ptf6 = self.probe_value(nt.am_trfms.pos1_to_num, vocab=self.v.item)
ptf7 = self.probe_value(nt.am_trfms.num_to_pos1, vocab=self.v.pos1)
ptf8 = self.probe_value(nt.am_trfms.pos_to_pos1, vocab=self.v.pos1)
self.add_graph('trfm ams', [p0, ptf5, ptf6, ptf7, ptf8],
[ptf5, ptf6, ptf7, ptf8])
if hasattr(self.m, 'bg') and True:
pbg1 = self.probe_value(self.m.bg.input)
pbg2 = self.probe_value(self.m.bg.output)
self.add_graph('bg', [p0, pbg1, pbg2])
if hasattr(self.m, 'dec') and True:
net = self.m.dec
pde1 = self.probe_value(net.item_dcconv, vocab=self.v.item)
# pde2 = self.probe_value(net.select_am)
# pde3 = self.probe_value(net.select_vis)
pde4 = self.probe_value(net.am_out, synapse=0.01, vocab=self.v.mtr)
# pde5 = self.probe_value(net.vt_out)
pde6 = self.probe_value(net.pos_mb_gate_sig.output)
# pde7 = self.probe_value(net.util_diff_neg)
pde8 = self.probe_value(net.am_utils)
pde9 = self.probe_value(net.am2_utils)
pde10 = self.probe_value(net.util_diff)
pde11 = self.probe_value(net.pos_recall_mb, vocab=self.v.pos)
# pde11a = self.probe_value(net.pos_recall_mb_in, vocab=self.v.pos)
pde11b = self.probe_value(net.fr_recall_mb.gate)
# pde11c = self.probe_value(net.fr_recall_mb.reset)
# pde11d = self.probe_value(net.fr_recall_mb.mem1.input,
# vocab=self.v.pos)
# pde11e = self.probe_value(net.fr_recall_mb.mem2.input,
# vocab=self.v.pos)
pde12 = self.probe_value(net.fr_dcconv.A, vocab=mem_vocab)
pde13 = self.probe_value(net.fr_dcconv.B, vocab=self.v.pos)
pde14 = self.probe_value(net.fr_dcconv.output, vocab=self.v.item)
# pde12 = self.probe_value(net.recall_mb.gateX)
# pde13 = self.probe_value(net.recall_mb.gateN)
# pde14a = self.probe_value(net.recall_mb.mem1.input)
# pde14b = self.probe_value(net.recall_mb.mem1.output)
# pde14c = self.probe_value(net.recall_mb.mem2.input)
# pde14d = self.probe_value(net.recall_mb.mem2.output)
# pde14e = self.probe_value(net.recall_mb.mem1.diff.output)
# pde14f = self.probe_value(net.recall_mb.reset)
# pde14g = self.probe_value(net.recall_mb.mem1.gate)
# pde12 = self.probe_value(net.dec_am_fr.output)
# pde13 = self.probe_value(net.dec_am.item_output)
# pde14 = self.probe_value(net.recall_mb.mem1.output)
pde15 = self.probe_value(net.output_know)
pde16 = self.probe_value(net.output_unk)
pde18 = self.probe_value(net.output_stop)
# pde19 = self.probe_value(net.am_th_utils)
# pde20 = self.probe_value(net.fr_th_utils)
pde21 = self.probe_value(net.output, vocab=self.v.mtr)
# pde22 = self.probe_value(net.dec_am_fr.input)
# pde23 = self.probe_value(net.am_def_th_utils)
# pde24 = self.probe_value(net.fr_def_th_utils)
pde25 = self.probe_value(net.fr_utils)
pde26 = self.probe_value(net.pos_mb_gate_bias.output)
pde27 = self.probe_value(net.pos_acc_input, vocab=self.v.pos)
pde28 = self.probe_value(net.item_dcconv_a, vocab=mem_vocab)
pde29 = self.probe_value(net.item_dcconv_b, vocab=self.v.pos)
sel_out_vocab = Vocabulary(5)
for n in range(5):
vec = np.zeros(5)
vec[n] = 1
sel_out_vocab.add('SEL%d' % n, vec)
pde30 = self.probe_value(net.sel_signals, vocab=sel_out_vocab)
pde31 = self.probe_value(net.select_out.input0,
vocab=self.v.mtr_disp)
pde32 = self.probe_value(net.select_out.input1,
vocab=self.v.mtr_disp)
pde33 = self.probe_value(net.select_out.input3,
vocab=self.v.mtr_disp)
pde34 = self.probe_value(net.out_class_sr_y)
pde35 = self.probe_value(net.out_class_sr_diff)
pde36 = self.probe_value(net.out_class_sr_n)
pde39 = self.probe_value(net.output_classify.fr_utils_n)
pde37 = self.probe_value(net.serial_decode.inhibit)
pde38 = self.probe_value(net.free_recall_decode.inhibit)
pde39 = self.probe_value(net.pos_change.output, label='POS Change')
self.add_graph('dec decconv', [pde28, pde29, pde1, pde4, pde21],
[pde21])
self.add_graph('dec kn unk st', [pde15, pde16, pde18])
self.add_graph('dec am utils', [pde8, pde9, pde10, pde25])
self.add_graph('dec sigs', [pde6, pde26, pde11, pde27, pde39])
self.add_graph('dec sr', [p0, pde37, pde38])
self.add_graph('dec fr', [pde11b, pde11, pde12, pde13, pde14])
self.add_graph('dec sel', [pde30, pde31, pde32, pde33], [pde30])
self.add_graph('dec out class', [pde34, pde35, pde36, pde39])
if hasattr(self.m, 'mtr'):
net = self.m.mtr
pmt1 = self.probe_value(net.ramp)
pmt2 = self.probe_value(net.ramp_reset_hold)
pmt2b = self.probe_value(net.ramp_sig.init_hold)
pmt3 = self.probe_value(net.motor_stop_input.output)
pmt4 = self.probe_value(net.motor_init.output)
pmt5 = self.probe_value(net.motor_go)
pmt6 = self.probe_value(net.ramp_sig.stop)
pmt7a = self.probe_value(net.arm_px_node)
pmt7b = self.probe_value(net.arm_py_node)
pmt8 = self.probe_value(net.pen_down, synapse=0.05)
pmt11 = self.probe_value(net.motor_bypass.output)
if hasattr(net, 'zero_centered_arm_ee_loc'):
pmt12 = self.probe_path(net.zero_centered_arm_ee_loc,
pmt8,
synapse=0.05)
else:
pmt12 = self.probe_null()
self.add_graph(
'mtr', [p0, pmt1, pmt2, pmt2b, pmt6, pmt3, pmt4, pmt5, pmt11])
self.add_graph('arm', [pmt7a, pmt7b, pmt8, pmt12])
def test_add():
v = Vocabulary(3)
v.add('A', [1, 2, 3])
v.add('B', [4, 5, 6])
v.add('C', [7, 8, 9])
assert np.allclose(v.vectors, [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
def initialize_probes(self):
# ===================== MAKE DISPLAY VOCABS ===========================
sub_vocab1 = self.v.enum.create_subset(['POS1*ONE', 'POS2*TWO',
'POS3*THR', 'POS4*FOR',
'POS5*FIV'])
sub_vocab2 = self.v.main.create_subset(['ADD'])
sub_vocab2.readonly = False
sub_vocab2.add('N_ADD', self.v.main.parse('~ADD'))
sub_vocab2.add('ADD*ADD', self.v.main.parse('ADD*ADD'))
sub_vocab2.add('ADD*ADD*ADD', self.v.main.parse('ADD*ADD*ADD'))
# sub_vocab2.add('ADD*ADD*ADD*ADD',
# self.v.main.parse('ADD*ADD*ADD*ADD'))
# sub_vocab2.add('ADD*ADD*ADD*ADD*ADD',
# self.v.main.parse('ADD*ADD*ADD*ADD*ADD'))
sub_vocab3 = self.v.main.create_subset([])
sub_vocab3.readonly = False
# sub_vocab3.add('N_POS1*ONE', self.v.main.parse('~(POS1*ONE)'))
# sub_vocab3.add('N_POS1*TWO', self.v.main.parse('~(POS1*TWO)'))
# sub_vocab3.add('N_POS1*THR', self.v.main.parse('~(POS1*THR)'))
# sub_vocab3.add('N_POS1*FOR', self.v.main.parse('~(POS1*FOR)'))
# sub_vocab3.add('N_POS1*FIV', self.v.main.parse('~(POS1*FIV)'))
sub_vocab3.add('ADD', self.v.main.parse('ADD'))
sub_vocab3.add('INC', self.v.main.parse('INC'))
vocab_seq_list = self.v.main.create_subset([])
vocab_seq_list.readonly = False
for sp_str in ['POS1*ONE', 'POS2*TWO', 'POS3*THR', 'POS4*FOR',
'POS5*FIV', 'POS6*SIX', 'POS7*SEV', 'POS8*EIG']:
vocab_seq_list.add(sp_str, self.v.main.parse(sp_str))
vocab_rpm = self.v.main.create_subset([])
vocab_rpm.readonly = False
for i in [1, 3, 8]:
sp_str = self.v.num_sp_strs[i]
vocab_rpm.add('A_(P1+P2+P3)*%s' % sp_str,
self.v.main.parse('POS1*%s+POS2*%s+POS3*%s' %
(sp_str, sp_str, sp_str)))
vocab_rpm.add('N_(P1+P2+P3)*%s' % sp_str,
self.v.main.parse('~(POS1*%s+POS2*%s+POS3*%s)' %
(sp_str, sp_str, sp_str)))
vocab_pos1 = self.v.main.create_subset([])
vocab_pos1.readonly = False
for sp_str in self.v.num_sp_strs:
p1_str = 'POS1*%s' % sp_str
vocab_pos1.add(p1_str, self.v.main.parse(p1_str))
# ----------- Default vocabs ------------------
mem_vocab = vocab_seq_list
# mem_vocab = vocab_pos1
# vocab_seq_list = vocab_rpm
# ========================= MAKE PROBES ===============================
if hasattr(self.m, 'stim'):
p0 = self.probe_image(self.m.stim.output, synapse=None,
shape=(28, 28))
else:
with self.m:
self.m.null_node = nengo.Node(0)
p0 = self.probe_value(self.m.null_node)
if hasattr(self.m, 'vis') and True:
net = self.m.vis
pvs1 = self.probe_value(net.output, vocab=self.v.vis_main)
pvs2 = self.probe_value(net.neg_attention)
pvs3 = self.probe_value(net.am_utilities)
pvs4 = self.probe_value(net.mb_output)
pvs5 = self.probe_value(net.vis_out)
self.add_graph('vis', [p0, pvs1, pvs2, pvs3])
self.add_graph('vis net', [pvs4, pvs5])
# ############ FOR DEBUGGING VIS DETECT SYSTEM ########################
# if hasattr(self.m, 'vis') and True:
# net = self.m.vis
# pvsd1 = self.probe_value(net.detect_change_net.input_diff)
# pvsd2 = self.probe_value(net.detect_change_net.item_detect)
# pvsd3 = self.probe_value(net.detect_change_net.blank_detect)
#
# self.add_graph('vis detect', [p0, pvsd1, pvsd2, pvsd3])
if hasattr(self.m, 'ps') and True:
net = self.m.ps
pps1 = self.probe_value(net.task, vocab=self.v.ps_task)
pps2 = self.probe_value(net.state, vocab=self.v.ps_state)
pps3 = self.probe_value(net.dec, vocab=self.v.ps_dec)
pps4 = self.probe_value(net.task_mb.mem1.output,
vocab=self.v.ps_task)
pps5 = self.probe_value(net.task_mb.mem2.output,
vocab=self.v.ps_task)
pps6 = self.probe_value(net.task_mb.mem1.input, synapse=None,
vocab=self.v.ps_task)
pps6b = self.probe_value(net.task_init.output)
pps7 = self.probe_value(net.state_mb.mem1.output,
vocab=self.v.ps_state)
pps8 = self.probe_value(net.state_mb.mem2.output,
vocab=self.v.ps_state)
pps9 = self.probe_value(net.state_mb.mem1.input, synapse=None,
vocab=self.v.ps_state)
pps10 = self.probe_value(net.dec_mb.mem1.output,
vocab=self.v.ps_dec)
pps11 = self.probe_value(net.dec_mb.mem2.output,
vocab=self.v.ps_dec)
pps12 = self.probe_value(net.dec_mb.mem1.input, synapse=None,
vocab=self.v.ps_dec)
pps13 = self.probe_value(net.task_mb.gate)
pps14 = self.probe_value(net.state_mb.gate)
pps15 = self.probe_value(net.dec_mb.gate)
pps13b = self.probe_value(net.task_mb.mem1.gate)
pps14b = self.probe_value(net.state_mb.mem1.gate)
pps15b = self.probe_value(net.dec_mb.mem1.gate)
pps13r = self.probe_value(net.task_mb.reset)
pps14r = self.probe_value(net.state_mb.reset)
pps15r = self.probe_value(net.dec_mb.reset)
pps16 = self.probe_value(net.action, vocab=self.v.ps_action_learn)
pps17 = self.probe_value(net.action_in,
vocab=self.v.ps_action_learn)
self.add_graph('ps', [p0, pps1, pps2, pps3], [pps1, pps2, pps3])
self.add_graph(
'ps_task',
[p0, pps6, pps4, pps5, pps6b, pps13, pps13b, pps13r],
[pps4, pps5, pps6])
self.add_graph(
'ps_state', [p0, pps9, pps7, pps8, pps14, pps14b, pps14r])
self.add_graph(
'ps_dec', [p0, pps12, pps10, pps11, pps15, pps15b, pps15r])
self.add_graph('ps_action', [p0, pps17, pps16], [pps16])
if hasattr(self.m, 'enc') and True:
net = self.m.enc
pen1 = self.probe_value(net.pos_inc.gate)
pen2 = self.probe_value(net.pos_inc.pos_mb.gateX)
pen4 = self.probe_value(net.pos_inc.output, vocab=self.v.pos)
pen5 = self.probe_value(net.pos_inc.pos_mb.mem1.output,
vocab=self.v.pos)
pen5b = self.probe_value(net.pos_inc.pos_mb.mem2.output,
vocab=self.v.pos)
pen6 = self.probe_value(net.pos_inc.reset)
# pen7 = self.probe_value(net.pos_mb_acc.output, vocab=self.v.pos)
# pen7a = self.probe_value(net.pos_mb_acc.input, vocab=self.v.pos)
# pen8 = self.probe_value(net.pos_output, vocab=self.v.pos)
self.add_graph('enc', [p0, pen1, pen2, pen4, pen5, pen5b, pen6],
[pen4])
if hasattr(self.m, 'mem') and True:
net = self.m.mem
pmm1 = self.probe_value(net.mb1, vocab=mem_vocab)
pmm1a = self.probe_value(net.mb1_net.mb_reh, vocab=mem_vocab)
pmm1b = self.probe_value(net.mb1_net.mb_dcy, vocab=mem_vocab)
pmm2 = self.probe_value(net.mb1_net.gate)
pmm3 = self.probe_value(net.mb1_net.reset)
pmm4 = self.probe_value(net.mb2, vocab=vocab_seq_list)
pmm5 = self.probe_value(net.mb2_net.gate)
pmm6 = self.probe_value(net.mb2_net.reset)
pmm7 = self.probe_value(net.mb3, vocab=vocab_seq_list)
pmm8 = self.probe_value(net.mb3_net.gate)
pmm9 = self.probe_value(net.mb3_net.reset)
self.add_graph('mb1', [p0, pmm1, pmm1a, pmm1b, pmm2, pmm3])
self.add_graph('mb2', [p0, pmm4, pmm5, pmm6])
self.add_graph('mb3', [p0, pmm7, pmm8, pmm9])
if hasattr(self.m, 'mem') and True:
net = self.m.mem
pmm1i = self.probe_value(net.input, vocab=mem_vocab)
pmm1ai = self.probe_value(net.mb1_net.mba.mem1.input,
vocab=mem_vocab)
pmm1bi = self.probe_value(net.mb1_net.mba.mem2.input,
vocab=mem_vocab)
pmm1g = self.probe_value(net.mb1_net.gate)
pmm1gx = self.probe_value(net.mb1_net.mba.gateX)
pmm1gn = self.probe_value(net.mb1_net.mba.gateN)
pmm1ag = self.probe_value(net.mb1_net.mba.mem1.gate)
pmm1bg = self.probe_value(net.mb1_net.mba.mem2.gate)
self.add_graph(
'mb1 details',
[pmm1i, pmm1ai, pmm1bi, pmm1a, pmm1g, pmm1gx, pmm1gn, pmm1ag,
pmm1bg])
if hasattr(self.m, 'mem') and True:
net = self.m.mem
pmm10 = self.probe_value(net.mbave_net.input, vocab=sub_vocab2)
pmm11 = self.probe_value(net.mbave_net.gate)
pmm12 = self.probe_value(net.mbave_net.reset)
pmm13 = self.probe_value(net.mbave, vocab=sub_vocab2)
pmm13a = self.probe_value(net.mbave)
self.add_graph('mbave', [p0, pmm10, pmm11, pmm12, pmm13, pmm13a],
[pmm10])
if hasattr(self.m, 'trfm') and \
not isinstance(self.m.trfm, TransformationSystemDummy):
net = self.m.trfm
ptf1 = self.probe_value(net.select_in_a.output, vocab=mem_vocab)
ptf2 = self.probe_value(net.select_in_b.output, vocab=mem_vocab)
ptf3 = self.probe_value(net.cconv1.output, vocab=vocab_rpm)
ptf3b = self.probe_value(ptf3)
# ptf3c = self.probe_value(ptf3)
# ptf3d = self.probe_value(ptf3)
ptf4 = self.probe_value(net.output, vocab=mem_vocab)
# ptf4b = self.probe_value(net.output)
ptf5 = self.probe_value(net.compare.output, vocab=self.v.ps_cmp)
ptf6 = self.probe_value(net.norm_a.output, vocab=sub_vocab1)
ptf7 = self.probe_value(net.norm_b.output, vocab=sub_vocab1)
ptf8 = self.probe_value(net.norm_a.input, vocab=sub_vocab1)
ptf9 = self.probe_value(net.norm_b.input, vocab=sub_vocab1)
ptf10 = self.probe_value(net.compare.dot_prod)
ptf11a = self.probe_value(net.cconv1.A, vocab=vocab_rpm)
ptf11b = self.probe_value(net.cconv1.B, vocab=vocab_rpm)
self.add_graph('trfm io', [p0, ptf1, ptf2, ptf4], [ptf1, ptf4])
self.add_graph('trfm cc', [p0, pmm11, ptf3, ptf3b, ptf11a, ptf11b])
self.add_graph(
'trfm cmp', [ptf5, ptf8, ptf6, ptf9, ptf7, ptf10],
[ptf6, ptf7])
if hasattr(self.m, 'trfm') and \
not isinstance(self.m.trfm, TransformationSystemDummy):
nt = self.m.trfm
ptf5 = self.probe_value(nt.am_trfms.pos1_to_pos, vocab=self.v.pos)
ptf6 = self.probe_value(nt.am_trfms.pos1_to_num, vocab=self.v.item)
ptf7 = self.probe_value(nt.am_trfms.num_to_pos1, vocab=self.v.pos1)
ptf8 = self.probe_value(nt.am_trfms.pos_to_pos1, vocab=self.v.pos1)
self.add_graph('trfm ams', [p0, ptf5, ptf6, ptf7, ptf8],
[ptf5, ptf6, ptf7, ptf8])
if hasattr(self.m, 'bg') and True:
pbg1 = self.probe_value(self.m.bg.input)
pbg2 = self.probe_value(self.m.bg.output)
self.add_graph('bg', [p0, pbg1, pbg2])
if hasattr(self.m, 'dec') and True:
net = self.m.dec
pde1 = self.probe_value(net.item_dcconv, vocab=self.v.item)
# pde2 = self.probe_value(net.select_am)
# pde3 = self.probe_value(net.select_vis)
pde4 = self.probe_value(net.am_out, synapse=0.01, vocab=self.v.mtr)
# pde5 = self.probe_value(net.vt_out)
pde6 = self.probe_value(net.pos_mb_gate_sig.output)
# pde7 = self.probe_value(net.util_diff_neg)
pde8 = self.probe_value(net.am_utils)
pde9 = self.probe_value(net.am2_utils)
pde10 = self.probe_value(net.util_diff)
pde11 = self.probe_value(net.pos_recall_mb, vocab=self.v.pos)
# pde11a = self.probe_value(net.pos_recall_mb_in, vocab=self.v.pos)
pde11b = self.probe_value(net.fr_recall_mb.gate)
# pde11c = self.probe_value(net.fr_recall_mb.reset)
# pde11d = self.probe_value(net.fr_recall_mb.mem1.input,
# vocab=self.v.pos)
# pde11e = self.probe_value(net.fr_recall_mb.mem2.input,
# vocab=self.v.pos)
pde12 = self.probe_value(net.fr_dcconv.A, vocab=mem_vocab)
pde13 = self.probe_value(net.fr_dcconv.B, vocab=self.v.pos)
pde14 = self.probe_value(net.fr_dcconv.output, vocab=self.v.item)
# pde12 = self.probe_value(net.recall_mb.gateX)
# pde13 = self.probe_value(net.recall_mb.gateN)
# pde14a = self.probe_value(net.recall_mb.mem1.input)
# pde14b = self.probe_value(net.recall_mb.mem1.output)
# pde14c = self.probe_value(net.recall_mb.mem2.input)
# pde14d = self.probe_value(net.recall_mb.mem2.output)
# pde14e = self.probe_value(net.recall_mb.mem1.diff.output)
# pde14f = self.probe_value(net.recall_mb.reset)
# pde14g = self.probe_value(net.recall_mb.mem1.gate)
# pde12 = self.probe_value(net.dec_am_fr.output)
# pde13 = self.probe_value(net.dec_am.item_output)
# pde14 = self.probe_value(net.recall_mb.mem1.output)
pde15 = self.probe_value(net.output_know)
pde16 = self.probe_value(net.output_unk)
pde18 = self.probe_value(net.output_stop)
# pde19 = self.probe_value(net.am_th_utils)
# pde20 = self.probe_value(net.fr_th_utils)
pde21 = self.probe_value(net.output, vocab=self.v.mtr)
# pde22 = self.probe_value(net.dec_am_fr.input)
# pde23 = self.probe_value(net.am_def_th_utils)
# pde24 = self.probe_value(net.fr_def_th_utils)
pde25 = self.probe_value(net.fr_utils)
pde26 = self.probe_value(net.pos_mb_gate_bias.output)
pde27 = self.probe_value(net.pos_acc_input, vocab=self.v.pos)
pde28 = self.probe_value(net.item_dcconv_a, vocab=mem_vocab)
pde29 = self.probe_value(net.item_dcconv_b, vocab=self.v.pos)
sel_out_vocab = Vocabulary(5)
for n in range(5):
vec = np.zeros(5)
vec[n] = 1
sel_out_vocab.add('SEL%d' % n, vec)
pde30 = self.probe_value(net.sel_signals, vocab=sel_out_vocab)
pde31 = self.probe_value(net.select_out.input0,
vocab=self.v.mtr_disp)
pde32 = self.probe_value(net.select_out.input1,
vocab=self.v.mtr_disp)
pde33 = self.probe_value(net.select_out.input3,
vocab=self.v.mtr_disp)
pde34 = self.probe_value(net.out_class_sr_y)
pde35 = self.probe_value(net.out_class_sr_diff)
pde36 = self.probe_value(net.out_class_sr_n)
pde39 = self.probe_value(net.output_classify.fr_utils_n)
pde37 = self.probe_value(net.serial_decode.inhibit)
pde38 = self.probe_value(net.free_recall_decode.inhibit)
pde39 = self.probe_value(net.pos_change.output, label='POS Change')
self.add_graph(
'dec decconv', [pde28, pde29, pde1, pde4, pde21], [pde21])
self.add_graph('dec kn unk st', [pde15, pde16, pde18])
self.add_graph('dec am utils', [pde8, pde9, pde10, pde25])
self.add_graph('dec sigs', [pde6, pde26, pde11, pde27, pde39])
self.add_graph('dec sr', [p0, pde37, pde38])
self.add_graph('dec fr', [pde11b, pde11, pde12, pde13, pde14])
self.add_graph('dec sel', [pde30, pde31, pde32, pde33], [pde30])
self.add_graph('dec out class', [pde34, pde35, pde36, pde39])
if hasattr(self.m, 'mtr'):
net = self.m.mtr
pmt1 = self.probe_value(net.ramp)
pmt2 = self.probe_value(net.ramp_reset_hold)
pmt2b = self.probe_value(net.ramp_sig.init_hold)
pmt3 = self.probe_value(net.motor_stop_input.output)
pmt4 = self.probe_value(net.motor_init.output)
pmt5 = self.probe_value(net.motor_go)
pmt6 = self.probe_value(net.ramp_sig.stop)
pmt7a = self.probe_value(net.arm_px_node)
pmt7b = self.probe_value(net.arm_py_node)
pmt8 = self.probe_value(net.pen_down, synapse=0.05)
pmt11 = self.probe_value(net.motor_bypass.output)
pmt12 = self.probe_path(net.zero_centered_arm_ee_loc,
pmt8, synapse=0.05)
self.add_graph(
'mtr', [p0, pmt1, pmt2, pmt2b, pmt6, pmt3, pmt4, pmt5, pmt11])
self.add_graph('arm', [pmt7a, pmt7b, pmt8, pmt12])
def main():
model = spa.SPA(label="Vector Storage")
with model:
# Dimensionality of each representation
num_dimensions = 30
sub_dimensions = 1
# Create the vocabulary
vocab = Vocabulary(num_dimensions, randomize=False)
# Form the inputs manually by directly defining their vectors
stored_value_1 = np.random.rand(num_dimensions) - [0.5
] * num_dimensions
stored_value_1 = [
s / np.linalg.norm(stored_value_1) for s in stored_value_1
]
vocab.add("Stored_value_1", stored_value_1)
stored_value_2 = np.random.rand(num_dimensions) - [0.5
] * num_dimensions
stored_value_2 = [
s / np.linalg.norm(stored_value_2) for s in stored_value_2
]
vocab.add("Stored_value_2", stored_value_2)
stored_value_3 = np.random.rand(num_dimensions) - [0.5
] * num_dimensions
stored_value_3 = [
s / np.linalg.norm(stored_value_3) for s in stored_value_3
]
vocab.add("Stored_value_3", stored_value_3)
# Create a semantic pointer corresponding to the "correct" answer for the operation
sum_vector = np.subtract(np.add(stored_value_1, stored_value_2),
stored_value_3)
sum_vector = sum_vector / np.linalg.norm(sum_vector)
vocab.add("Sum", sum_vector)
# Define the control signal inputs as random vectors
r1 = [1] * num_dimensions
r1 = r1 / np.linalg.norm(r1)
r2 = [(-1)**k for k in range(num_dimensions)]
r2 = r2 / np.linalg.norm(r2)
vocab.add("Hold_signal", r1)
vocab.add("Start_signal", r2)
# Control when the vector operation takes place
def control_input(t):
if t < 1:
return "Hold_signal"
else:
return "Start_signal"
# inputs to the input word buffers
def first_input(t):
return "Stored_value_1"
def second_input(t):
return "Stored_value_2"
def third_input(t):
return "Stored_value_3"
# Control buffer
model.control = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
control_probe = nengo.Probe(model.control.state.output)
# Buffers to store the inputs: e.g., King, Man, Woman
model.word_buffer1 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
model.word_buffer2 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
model.word_buffer3 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
# Probe to visualize the values stored in the buffers
buffer_1_probe = nengo.Probe(model.word_buffer1.state.output)
buffer_2_probe = nengo.Probe(model.word_buffer2.state.output)
buffer_3_probe = nengo.Probe(model.word_buffer3.state.output)
# Buffer to hold the result: e.g. Queen
model.result = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
result_probe = nengo.Probe(model.result.state.output)
# Control system
actions = spa.Actions(
'dot(control, Start_signal) --> result = word_buffer1 + word_buffer2 - word_buffer3'
)
model.bg = spa.BasalGanglia(actions)
model.thalamus = spa.Thalamus(model.bg, subdim_channel=sub_dimensions)
# Connect up the inputs
model.input = spa.Input(control=control_input,
word_buffer1=first_input,
word_buffer2=second_input,
word_buffer3=third_input)
# Start the simulator
sim = nengo.Simulator(model)
# Dynamic plotting
plt.ion() # Dynamic updating of plots
fig = plt.figure(figsize=(15, 8))
plt.show()
ax = fig.gca()
ax.set_title("Vector Storage")
while True:
sim.run(1) # Run for an additional 1 second
plt.clf() # Clear the figure
plt.plot(sim.trange(),
similarity(sim.data, result_probe, vocab),
label="Buffer 3 Value")
plt.legend(vocab.keys * 3, loc=2)
plt.draw() # Re-draw
print sim.data[buffer_1_probe][-1]
print sim.data[buffer_2_probe][-1]
print sim.data[buffer_3_probe][-1]
print sim.data[result_probe][-1]
print "\n"
plt.show()
# --- Unitary semantic pointers
unitary_sp_strs = [num_sp_strs[0], pos_sp_strs[0]]
unitary_sp_strs.extend(ops_sp_strs)
# ####################### Vocabulary definitions ##############################
# --- Primary vocabulary ---
vocab = Vocabulary(cfg.sp_dim, unitary=unitary_sp_strs, rng=cfg.rng)
# --- Add numerical sp's ---
vocab.parse('%s+%s' % (ops_sp_strs[0], num_sp_strs[0]))
add_sp = vocab[ops_sp_strs[0]]
num_sp = vocab[num_sp_strs[0]].copy()
for i in range(len(num_sp_strs) - 1):
num_sp = num_sp.copy() * add_sp
vocab.add(num_sp_strs[i + 1], num_sp)
# --- Add positional sp's ---
vocab.parse('%s+%s' % (ops_sp_strs[1], pos_sp_strs[0]))
inc_sp = vocab[ops_sp_strs[1]]
pos_sp = vocab[pos_sp_strs[0]].copy()
for i in range(len(pos_sp_strs) - 1):
pos_sp = pos_sp.copy() * inc_sp
vocab.add(pos_sp_strs[i + 1], pos_sp)
# --- Add other visual sp's ---
vocab.parse('+'.join(misc_vis_sp_strs))
vocab.parse('+'.join(ps_task_vis_sp_strs))
# --- Add production system sp's ---
vocab.parse('+'.join(ps_task_sp_strs))
def test_add(rng):
v = Vocabulary(3, rng=rng)
v.add("A", [1, 2, 3])
v.add("B", [4, 5, 6])
v.add("C", [7, 8, 9])
assert np.allclose(v.vectors, [[1, 2, 3], [4, 5, 6], [7, 8, 9]])
def main():
print "Loading Word2Vec model..."
word2vec_model = gensim.models.Word2Vec.load("word2vec_model_1_cleaned")
word2vec_model.init_sims(replace=True)
word2vec_vocab = word2vec_model.index2word
import readline
readline.parse_and_bind("tab: complete")
def complete(text, state):
results = [x for x in word2vec_vocab if x.startswith(text)] + [None]
return results[state]
readline.set_completer(complete)
print "This program uses an SPA network in Nengo to perform vector operations on a semantically structured word-vector space *learned* from a sentence corpus."
print "When trained on a large corpus of English sentences, for example, it should produce: Vector[king] - Vector[man] + Vector[woman] = Vector[king]"
print "For now, it just does subtraction..."
print "\nPress <tab> twice to see all your autocomplete options."
print "_______________________________________________________"
line1 = raw_input('\nFirst word:> ')
line2 = raw_input('\nSecond word:> ')
if line1 and line2 in word2vec_vocab:
val1 = word2vec_model[line1]
val2 = word2vec_model[line2]
diff = val1 - val2
dot_products = [
np.dot(word2vec_model[word2vec_model.index2word[i]], diff)
for i in range(len(word2vec_model.index2word))
]
closest_word = word2vec_model.index2word[dot_products.index(
max(dot_products))]
print "\nWhat the Nengo model SHOULD return is something like: %s" % closest_word
print "\nDefining SPA network..."
model = spa.SPA(label="Vector Storage")
with model:
# Dimensionality of each representation
num_dimensions = 100
sub_dimensions = 1
# Create the vocabulary
vocab = Vocabulary(num_dimensions, randomize=False)
stored_value_1 = val1
vocab.add("Stored_value_1", stored_value_1)
stored_value_2 = val2
vocab.add("Stored_value_2", stored_value_2)
# Create a semantic pointer corresponding to the "correct" answer for the operation
sum_vector = np.subtract(stored_value_1, stored_value_2)
sum_vector = sum_vector / np.linalg.norm(sum_vector)
vocab.add("Correct_target", sum_vector)
# Define the control signal inputs as random vectors
r1 = [1] * num_dimensions
r1 = r1 / np.linalg.norm(r1)
r2 = [(-1)**k for k in range(num_dimensions)]
r2 = r2 / np.linalg.norm(r2)
vocab.add("Hold_signal", r1)
vocab.add("Start_signal", r2)
# Control when the vector operation takes place
def control_input(t):
if t < 1:
return "Hold_signal"
else:
return "Start_signal"
# Control buffer
model.control = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
control_probe = nengo.Probe(model.control.state.output)
# Inputs to the word input buffers
def first_input(t):
return "Stored_value_1"
def second_input(t):
return "Stored_value_2"
# Buffers to store the inputs:
model.word_buffer1 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
model.word_buffer2 = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
# Probe to visualize the values stored in the buffers
buffer_1_probe = nengo.Probe(model.word_buffer1.state.output)
buffer_2_probe = nengo.Probe(model.word_buffer2.state.output)
# Buffer to hold the result:
model.result = spa.Buffer(dimensions=num_dimensions,
subdimensions=sub_dimensions,
neurons_per_dimension=200,
direct=True,
vocab=vocab)
result_probe = nengo.Probe(model.result.state.output)
# Control system
actions = spa.Actions(
'dot(control, Start_signal) --> result = word_buffer1 - word_buffer2',
'dot(control, Hold_signal) --> result = Hold_signal')
model.bg = spa.BasalGanglia(actions)
model.thalamus = spa.Thalamus(model.bg, subdim_channel=sub_dimensions)
# Connect up the inputs
model.input = spa.Input(control=control_input,
word_buffer1=first_input,
word_buffer2=second_input)
# Start the simulator
sim = nengo.Simulator(model)
# Dynamic plotting
plt.ion() # Dynamic updating of plots
fig = plt.figure(figsize=(15, 8))
plt.show()
ax = fig.gca()
ax.set_title("Vector Storage")
while True:
sim.run(0.5) # Run for an additional 1 second
plt.clf() # Clear the figure
plt.plot(sim.trange(),
similarity(sim.data, result_probe, vocab),
label="Buffer 3 Value")
legend_symbols = vocab.keys
plt.legend(legend_symbols, loc=2)
plt.draw() # Re-draw
# Go back to our manually-stored vocabulary and see how well it did
diff = sim.data[result_probe][-1]
dot_products = [
np.dot(word2vec_model[word2vec_model.index2word[i]], diff)
for i in range(len(word2vec_model.index2word))
]
closest_word = word2vec_model.index2word[dot_products.index(
max(dot_products))]
print "Time: %f" % sim.trange()[-1]
print "\nWhat the Nengo model DID return is something like: %s" % closest_word
print "\n"
plt.show()
