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