def extract_data(filename, sim, address_input_p, stored_input_p, pre_probes,
cleanup_s, output_probes, address_vectors, stored_vectors,
testing_vectors, correct_vectors, **kwargs):
t = sim.trange()
address_input, _ = extract_probe_data(t, sim, address_input_p)
stored_input, _ = extract_probe_data(t, sim, stored_input_p)
pre_decoded, _ = extract_probe_data(t, sim, pre_probes)
cleanup_spikes, _ = extract_probe_data(t, sim, cleanup_s, spikes=True)
output_decoded, _ = extract_probe_data(t, sim, output_probes)
def make_sim_func(h):
def sim(vec):
return h.compare(hrr.HRR(data=vec))
return sim
print len(stored_vectors)
print len(address_vectors)
print address_vectors
address_sim_funcs = [
make_sim_func(hrr.HRR(data=h)) for h in address_vectors
]
stored_sim_funcs = [make_sim_func(hrr.HRR(data=h)) for h in stored_vectors]
output_sim, _ = extract_probe_data(t,
sim,
output_probes,
func=stored_sim_funcs)
input_sim, _ = extract_probe_data(t,
sim,
address_input_p,
func=address_sim_funcs)
ret = dict(t=t,
address_input=address_input,
stored_input=stored_input,
pre_decoded=pre_decoded,
cleanup_spikes=cleanup_spikes,
output_decoded=output_decoded,
output_sim=output_sim,
input_sim=input_sim,
correct_vectors=correct_vectors,
testing_vectors=testing_vectors)
fh.npsave(filename, **ret)
return ret
def make_hrr_vectors(G, id_vectors, edge_vectors):
max_out_degree = len(edge_vectors)
index_dict = {}
for n in G.nodes_iter():
edges = G.edges(n)
indices = random.sample(range(max_out_degree), len(edges))
index_dict.update(dict(zip(edges, indices)))
nx.set_edge_attributes(G, 'index', index_dict)
hrrvecs = {}
for n in G.nodes_iter():
edges = G.edges(n)
if not edges:
hrr_vec = hrr.HRR(len(id_vectors.values()[0]))
else:
components = [
id_vectors[e[1]].convolve(edge_vectors[index_dict[e]])
for e in edges
]
hrrvec = sum(components[1:], components[0])
hrrvec.normalize()
hrrvecs[n] = hrrvec
return hrrvecs
def run(sim_type, dim, DperE, cleanup_n):
sim_class = {0: nengo.Simulator, 1: SimOCL}[sim_type]
input_vector = hrr.HRR(dim).v
cleanup_encoders = np.array([input_vector] * cleanup_n)
num_ensembles = int(dim / DperE)
dim = num_ensembles * DperE
NperE = NperD * DperE
print "Building..."
start = time.time()
model = nengo.Model("PES timing", seed=seed)
def input_func(x):
return input_vector
inn = nengo.Node(output=input_func)
# Build ensembles
cleanup = nengo.Ensemble(label='cleanup',
neurons=nengo.LIF(cleanup_n),
dimensions=dim,
encoders=cleanup_encoders)
nengo.Connection(inn, cleanup)
ensembles = \
build.build_cleanup_pes(cleanup, inn, DperE, NperD, num_ensembles, learning_rate)
output_ensembles = ensembles[0]
error_ensembles = ensembles[1]
# Build probes
output_probes = [
nengo.Probe(o, 'decoded_output', filter=0.1) for o in output_ensembles
]
error_probes = [
nengo.Probe(e, 'decoded_output', filter=0.1) for e in error_ensembles
]
input_probe = nengo.Probe(inn, 'output')
end = time.time()
print "Build Time: ", end - start
# Run model
print "Simulating..."
start = time.time()
sim = sim_class(model, dt=0.001)
sim.run(sim_length)
end = time.time()
print "Sim Time: ", end - start
end = time.time()
print "Plot Time: ", end - start
overall_end = time.time()
print "Total time: ", overall_end - overall_start
plt.show()
def hrrnoise(D, expression, normalize=False):
normalize = bool(normalize)
D = int(D)
f = nf.make_hrr_noise_from_string(D,
expression,
normalize=normalize,
verbose=True)
i = hrr.HRR(D)
x = f(i)
print 'Compare: ', i.compare(x)
print 'Dot: ', np.dot(i.v, x.v)
def build_and_run_vectors(seed, dim, DperE, NperD, num_vectors,
neurons_per_vector, training_time, testing_time,
cleanup_params, ensemble_params, oja_learning_rate,
oja_scale, pre_tau, post_tau, pes_learning_rate,
**kwargs):
cleanup_n = neurons_per_vector * num_vectors
vocab = hrr.Vocabulary(dim)
training_vectors = [
vocab.parse("x" + str(i)).v for i in range(num_vectors)
]
print "Training Vector Similarities:"
simils = []
if num_vectors > 1:
for a, b in itertools.combinations(training_vectors, 2):
s = np.dot(a, b)
simils.append(s)
print s
print "Mean"
print np.mean(simils)
print "Max"
print np.max(simils)
print "Min"
print np.min(simils)
noise = nf.make_hrr_noise(dim, 2)
testing_vectors = [noise(tv) for tv in training_vectors] + [hrr.HRR(dim).v]
ret = build_and_run(seed, dim, DperE, NperD, cleanup_n, training_vectors,
training_vectors, testing_vectors, training_time,
testing_time, cleanup_params, ensemble_params,
oja_learning_rate, oja_scale, pre_tau, post_tau,
pes_learning_rate)
return ret
with np.load(f) as npz:
sims, sims_time = npz['sims'], npz['sims_time']
before_spikes, before_time = npz['before_spikes'], npz['before_time']
after_spikes, after_time = npz['after_spikes'], npz['after_time']
print "Loaded"
except:
print "Couldn't load."
run_sim = True
if run_sim:
print "Building..."
start = time.time()
model = nengo.Model("Network Array OJA", seed=seed)
training_vector = np.array(hrr.HRR(dim).v)
ortho = nf.ortho_vector(training_vector)
ortho2 = nf.ortho_vector(training_vector)
hrr_noise = nf.make_hrr_noise(dim, hrr_num)
noisy_vector = hrr_noise(training_vector)
print "HRR sim: ", np.dot(noisy_vector, training_vector)
# --- Build input for phase 1
gens1 = [
nf.interpolator(1, ortho, training_vector,
lambda x: np.true_divide(x, ttms)),
nf.interpolator(1, training_vector,
ortho, lambda x: np.true_divide(x, ttms)),
nf.interpolator(1, ortho, noisy_vector,
lambda x: np.true_divide(x, ttms)),
ensemble_params = {
"radius": pre_radius,
"max_rates": pre_max_rates,
"intercepts": pre_intercepts
}
oja_scale = np.true_divide(20, 1)
oja_learning_rate = np.true_divide(1, 50)
pre_tau = 0.03
post_tau = 0.03
print "Building..."
start = time.time()
model = nengo.Model("Network Array OJA", seed=seed)
training_vector = np.array(hrr.HRR(dim).v)
ortho = nf.ortho_vector(training_vector)
ortho2 = nf.ortho_vector(training_vector)
hrr_noise = nf.make_hrr_noise(dim, hrr_num)
noisy_vector = hrr_noise(training_vector)
print "HRR sim: ", np.dot(noisy_vector, training_vector)
# --- Build input for phase 1
gens1 = [
nf.interpolator(1, training_vector, ortho,
lambda x: np.true_divide(x, ttms)),
nf.interpolator(1, ortho, training_vector,
lambda x: np.true_divide(x, ttms)),
nf.interpolator(1, noisy_vector, ortho, lambda x: np.true_divide(x, ttms)),
nf.interpolator(1, ortho, noisy_vector, lambda x: np.true_divide(x, ttms)),
def sim(vec):
return h.compare(hrr.HRR(data=vec))
sim_length = 2
DperE = 2
dim = 16
num_ensembles = int(dim / DperE)
dim = num_ensembles * DperE
cleanup_n = 20
NperD = 30
NperE = NperD * DperE
seed = 123
random.seed(seed)
learning_rate = np.true_divide(1, 5)
input_vector = hrr.HRR(dim).v
cleanup_encoders = np.array([input_vector] * cleanup_n)
print "Building..."
start = time.time()
model = nengo.Model("Network Array PES", seed=seed)
def input_func(x):
return input_vector
inn = nengo.Node(output=input_func)
# Build ensembles
cleanup = nengo.Ensemble(label='cleanup',
def run(sim_type, dim, DperE, cleanup_n):
sim_class = {0: nengo.Simulator, 1: SimOCL}[sim_type]
print "sim_class: ", sim_class, "dim: ", dim, "DperE: ", DperE, "cleanup_n: ", cleanup_n
print "Building..."
num_ensembles = int(dim / DperE)
dim = num_ensembles * DperE
NperE = NperD * DperE
pre_max_rates = [400] * NperE
pre_intercepts = [0.1] * NperE
pre_radius = 1.0
ensemble_params = {
"radius": pre_radius,
"max_rates": pre_max_rates,
"intercepts": pre_intercepts
}
start = time.time()
training_vector = np.array(hrr.HRR(dim).v)
start = time.time()
# ----- Make Nodes -----
model = nengo.Model("Oja Timing", seed=seed)
with model:
inn = nengo.Node(output=lambda x: [0] * dim)
cleanup = nengo.Ensemble(label='cleanup',
neurons=nengo.LIF(cleanup_n),
dimensions=dim,
max_rates=max_rates * cleanup_n,
intercepts=intercepts * cleanup_n,
radius=radius)
pre_decoders = {
'pre_' + str(i): np.zeros((dim, NperE))
for i in range(num_ensembles)
}
encoders = np.zeros((cleanup_n, dim))
pre_ensembles, pre_decoders, pre_connections = \
build.build_cleanup_oja(model, inn, cleanup, DperE, NperD, num_ensembles,
ensemble_params, oja_learning_rate, oja_scale,
pre_decoders=pre_decoders, encoders=encoders, pre_tau=pre_tau, post_tau=post_tau,
end_time=None)
cleanup_s = nengo.Probe(cleanup, 'spikes')
#cleanup_w = nengo.Probe(pre_connections[0], 'transform')
end = time.time()
build_time = end - start
print "Time:", build_time
# ----- Run and get data-----
print "Running..."
start = time.time()
sim = sim_class(model, dt=0.001)
sim.run(run_time)
x = sim.data(cleanup_w)
print x.shape
end = time.time()
sim_time = end - start
print "Time:", sim_time
return sim_time, build_time