def build_association(self): tau_rc = self.assoc_params.tau_rc tau_ref = self.assoc_params.tau_ref radius = self.assoc_params.radius eval_points = self.assoc_params.eval_points intercepts = self.assoc_params.intercepts # Add a nengo.Node which calls out to a GPU library for # simulating the associative memory self.assoc_memory = \ AssociativeMemoryGPU(self.gpus, self.index_vectors, self.stored_vectors, threshold=self.threshold, neurons_per_item=self.neurons_per_item, tau_ref=tau_ref, tau_rc=tau_rc, eval_points=eval_points, intercepts=intercepts, radius=radius, do_print=False, identical=self.identical, probe_keys=self.probe_keys, seed=self.seed, num_steps=self.timesteps) self.assoc_output = np.zeros((1, self.dimension))
def build_association(self): tau_rc = self.assoc_params.tau_rc tau_ref = self.assoc_params.tau_ref radius = self.assoc_params.radius eval_points = self.assoc_params.eval_points intercepts = self.assoc_params.intercepts # Add a nengo.Node which calls out to a GPU library for # simulating the associative memory self.assoc_memory = \ AssociativeMemoryGPU(self.gpus, self.index_vectors, self.stored_vectors, threshold=self.threshold, neurons_per_item=self.neurons_per_item, tau_ref=tau_ref, tau_rc=tau_rc, eval_points=eval_points, intercepts=intercepts, radius=radius, do_print=False, identical=self.identical, probe_keys=self.probe_keys, seed=self.seed, num_steps=self.timesteps) self.assoc_output = np.zeros((1, self.dimension))
class FastNeuralExtractor(NeuralExtractor): _type = "Neural" def __init__(self, *args, **kwargs): """ A GPU neural associative memory with a unique simulation strategy. Instead of making one big model with all the necessary components in it, we make multiple models, and simulate each completely before simulating the next one. The main benefit of this is that the GPU won't have to pause every time step to load data on and off. This is made possible by the fact that the network is completely feedforward, and so earlier components can be simulated without requiring input from later components. index_vectors and stored_vectors are both dictionaries mapping from tuples of the form (POS, number), indicating a synset, to numpy ndarrays containing the assigned vector """ super(FastNeuralExtractor, self).__init__(*args, **kwargs) def setup_simulator(self): self.unbind_model = nengo.Network(label="Unbind", seed=self.seed) self.build_unbind(self.unbind_model) self.build_association() self.output_model = nengo.Network(label="Output", seed=self.seed) self.build_output(self.output_model) print "Building simulators" self.unbind_simulator = self.build_simulator(self.unbind_model) self.output_simulator = self.build_simulator(self.output_model) self.simulator = self.output_simulator def build_association(self): tau_rc = self.assoc_params.tau_rc tau_ref = self.assoc_params.tau_ref radius = self.assoc_params.radius eval_points = self.assoc_params.eval_points intercepts = self.assoc_params.intercepts # Add a nengo.Node which calls out to a GPU library for # simulating the associative memory self.assoc_memory = \ AssociativeMemoryGPU(self.gpus, self.index_vectors, self.stored_vectors, threshold=self.threshold, neurons_per_item=self.neurons_per_item, tau_ref=tau_ref, tau_rc=tau_rc, eval_points=eval_points, intercepts=intercepts, radius=radius, do_print=False, identical=self.identical, probe_keys=self.probe_keys, seed=self.seed, num_steps=self.timesteps) self.assoc_output = np.zeros((1, self.dimension)) def build_output(self, model): assoc_probes = OrderedDict() threshold_probes = OrderedDict() assoc_spike_probes = OrderedDict() synapse = self.assoc_params.synapse with model: input = nengo.Node(output=self.assoc_output_func) output = EnsembleArray(n_neurons=self.neurons_per_dim, n_ensembles=self.dimension, label="output", radius=self.radius) nengo.Connection(input, output.input, synapse=synapse) self.output_probe = nengo.Probe(output.output, 'output', synapse=0.02) for k in self.probe_keys: n = nengo.Node(output=self.assoc_memory.probe_func(k)) probe = nengo.Probe(n, synapse=synapse) threshold_probes[k] = probe node = nengo.Node(output=self.assoc_memory.spike_func(k)) assoc_spike_probes[k] = nengo.Probe(node, synapse=None) self.assoc_probes = assoc_probes self.threshold_probes = threshold_probes self.assoc_spike_probes = assoc_spike_probes def extract(self, item, query, *args, **kwargs): self.print_instance_difficulty(item, query) then = datetime.datetime.now() self.A_input_vector = item self.B_input_vector = query print "Simulating unbind model" self.unbind_simulator.run(self.timesteps * self.dt) assoc_input = self.unbind_simulator.data[self.D_probe] print "Simulating associative memory" self.assoc_output = self.assoc_memory.multi_step(assoc_input) self.output_index = 0 print "Simulating output" self.output_simulator.run(self.timesteps * self.dt) now = datetime.datetime.now() self.write_to_runtime_file(now - then, "unbind") # for plotting self.data = {k: v for (k, v) in self.output_simulator.data.iteritems()} self.data[self.D_probe] = self.unbind_simulator.data[self.D_probe] self.data[self.input_probe] = \ self.unbind_simulator.data[self.input_probe] if self.plot: self.plot_simulation() vector = self.data[self.output_probe][-1, :] return [vector] def assoc_output_func(self, t): index = int(t / self.dt) return self.assoc_output[index] def reset_nodes(self): pass def write_to_runtime_file(self, delta, label=''): to_print = [ self.dimension, self.num_items, self.neurons_per_item, self.neurons_per_dim, self.timesteps, "OCL: " + str(self.ocl), "GPUS: " + str(self.gpus), "fast", delta ] print >> self.runtimes_file, label, \ ": " ",".join([str(tp) for tp in to_print]) def print_config(self, output_file): super(FastNeuralExtractor, self).print_config(output_file) output_file.write("Fast neural extractor config:\n")
def build_association(self, model): tau_rc = self.assoc_params.tau_rc tau_ref = self.assoc_params.tau_ref synapse = self.assoc_params.synapse radius = self.assoc_params.radius eval_points = self.assoc_params.eval_points intercepts = self.assoc_params.intercepts neurons_per_item = self.neurons_per_item threshold = self.threshold assoc_probes = OrderedDict() threshold_probes = OrderedDict() assoc_spike_probes = OrderedDict() with model: if self.gpus: if not self.identical: raise NotImplementedError( "Currently, can only use gpu if --identical " "is also specified") # Add a nengo.Node which calls out to a GPU library for # simulating the associative memory self.assoc_mem = \ AssociativeMemoryGPU(self.gpus, self.index_vectors, self.stored_vectors, threshold=threshold, neurons_per_item=neurons_per_item, tau_ref=tau_ref, tau_rc=tau_rc, eval_points=eval_points, intercepts=intercepts, radius=radius, do_print=False, identical=self.identical, probe_keys=self.probe_keys, seed=self.seed, collect_spikes=self.collect_spikes) def gpu_function(t, input_vector): output_vector = self.assoc_mem.step(input_vector) return output_vector assoc = nengo.Node(output=gpu_function, size_in=self.dimension, size_out=self.dimension) nengo.Connection(self.D_output, assoc, synapse=synapse) nengo.Connection(assoc, self.output.input, synapse=synapse) for k in self.probe_keys: node = nengo.Node(output=self.assoc_mem.probe_func(k)) probe = nengo.Probe(node, synapse=synapse) threshold_probes[k] = probe node = nengo.Node(output=self.assoc_mem.spike_func(k)) assoc_spike_probes[k] = nengo.Probe(node, synapse=None) else: self.assoc_mem = AssociativeMemory( input_vocab=np.array(self.index_vectors.values()), output_vocab=np.array(self.stored_vectors.values()), threshold=self.threshold, neuron_type=nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref), n_neurons_per_ensemble=neurons_per_item) nengo.Connection(self.D_output, self.assoc_mem.input, synapse=synapse) nengo.Connection(self.assoc_mem.output, self.output.input, synapse=synapse) assoc_ensembles = ( self.assoc_mem.thresholded_ens_array.ea_ensembles) for ens, k in zip(assoc_ensembles, self.index_vectors): if k in self.probe_keys: assoc_probes[k] = nengo.Probe(ens, 'decoded_output', synapse=synapse) assoc_spike_probes[k] = nengo.Probe(ens.neurons, 'spikes', synapse=None) self.assoc_probes = assoc_probes self.threshold_probes = threshold_probes self.assoc_spike_probes = assoc_spike_probes
def build_association(self, model): tau_rc = self.assoc_params.tau_rc tau_ref = self.assoc_params.tau_ref synapse = self.assoc_params.synapse radius = self.assoc_params.radius eval_points = self.assoc_params.eval_points intercepts = self.assoc_params.intercepts neurons_per_item = self.neurons_per_item threshold = self.threshold assoc_probes = OrderedDict() threshold_probes = OrderedDict() assoc_spike_probes = OrderedDict() with model: if self.gpus: if not self.identical: raise NotImplementedError( "Currently, can only use gpu if --identical " "is also specified") # Add a nengo.Node which calls out to a GPU library for # simulating the associative memory self.assoc_mem = \ AssociativeMemoryGPU(self.gpus, self.index_vectors, self.stored_vectors, threshold=threshold, neurons_per_item=neurons_per_item, tau_ref=tau_ref, tau_rc=tau_rc, eval_points=eval_points, intercepts=intercepts, radius=radius, do_print=False, identical=self.identical, probe_keys=self.probe_keys, seed=self.seed, collect_spikes=self.collect_spikes) def gpu_function(t, input_vector): output_vector = self.assoc_mem.step(input_vector) return output_vector assoc = nengo.Node(output=gpu_function, size_in=self.dimension, size_out=self.dimension) nengo.Connection(self.D_output, assoc, synapse=synapse) nengo.Connection(assoc, self.output.input, synapse=synapse) for k in self.probe_keys: node = nengo.Node(output=self.assoc_mem.probe_func(k)) probe = nengo.Probe(node, synapse=synapse) threshold_probes[k] = probe node = nengo.Node(output=self.assoc_mem.spike_func(k)) assoc_spike_probes[k] = nengo.Probe(node, synapse=None) else: #print(self.index_vectors) #print(self.stored_vectors) ''' index_vocab = Vocabulary(128) stored_vocab = Vocabulary(128) #index_vocab = Vocabulary(len(self.index_vectors.values())) #stored_vocab = Vocabulary(len(self.stored_vectors.values())) import string chars = list(string.ascii_uppercase) import random for idx, vector in enumerate(self.index_vectors.values()): generated_key = ''.join([chars[i] for i in random.sample(range(len(chars)), len(chars)-1)]) print('index_len: {}'.format(np.shape(vector))) print(vector) index_vocab.add(generated_key, vector) for idx, vector in enumerate(self.stored_vectors.values()): generated_key = ''.join([chars[i] for i in random.sample(range(len(chars)), len(chars)-1)]) print('stored_len: {}'.format(np.shape(vector))) stored_vocab.add(generated_key, vector) ''' self.assoc_mem = AssociativeMemory( input_vectors=self.index_vectors.values(), output_vectors=self.stored_vectors.values(), threshold=self.threshold, n_neurons=neurons_per_item) #neuron_type=nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref), #n_neurons_per_ensemble=neurons_per_item) self.assoc_mem.add_threshold_to_outputs(neurons_per_item) #self.assoc_mem = AssociativeMemory( # input_vocab=index_vocab, # output_vocab=stored_vocab, # threshold=self.threshold, # ) #neuron_type=nengo.LIF(tau_rc=tau_rc, tau_ref=tau_ref), #n_neurons_per_ensemble=neurons_per_item) nengo.Connection(self.D_output, self.assoc_mem.input, synapse=synapse) nengo.Connection(self.assoc_mem.output, self.output.input, synapse=synapse) assoc_ensembles = (self.assoc_mem.thresh_ens.ensembles) #self.assoc_mem.thresholded_ens_array.ea_ensembles) for ens, k in zip(assoc_ensembles, self.index_vectors): if k in self.probe_keys: assoc_probes[k] = nengo.Probe(ens, 'decoded_output', synapse=synapse) assoc_spike_probes[k] = nengo.Probe(ens.neurons, 'spikes', synapse=None) self.assoc_probes = assoc_probes self.threshold_probes = threshold_probes self.assoc_spike_probes = assoc_spike_probes
class FastNeuralExtractor(NeuralExtractor): _type = "Neural" def __init__(self, *args, **kwargs): """ A GPU neural associative memory with a unique simulation strategy. Instead of making one big model with all the necessary components in it, we make multiple models, and simulate each completely before simulating the next one. The main benefit of this is that the GPU won't have to pause every time step to load data on and off. This is made possible by the fact that the network is completely feedforward, and so earlier components can be simulated without requiring input from later components. index_vectors and stored_vectors are both dictionaries mapping from tuples of the form (POS, number), indicating a synset, to numpy ndarrays containing the assigned vector """ super(FastNeuralExtractor, self).__init__(*args, **kwargs) def setup_simulator(self): self.unbind_model = nengo.Network(label="Unbind", seed=self.seed) self.build_unbind(self.unbind_model) self.build_association() self.output_model = nengo.Network(label="Output", seed=self.seed) self.build_output(self.output_model) print "Building simulators" self.unbind_simulator = self.build_simulator(self.unbind_model) self.output_simulator = self.build_simulator(self.output_model) self.simulator = self.output_simulator def build_association(self): tau_rc = self.assoc_params.tau_rc tau_ref = self.assoc_params.tau_ref radius = self.assoc_params.radius eval_points = self.assoc_params.eval_points intercepts = self.assoc_params.intercepts # Add a nengo.Node which calls out to a GPU library for # simulating the associative memory self.assoc_memory = \ AssociativeMemoryGPU(self.gpus, self.index_vectors, self.stored_vectors, threshold=self.threshold, neurons_per_item=self.neurons_per_item, tau_ref=tau_ref, tau_rc=tau_rc, eval_points=eval_points, intercepts=intercepts, radius=radius, do_print=False, identical=self.identical, probe_keys=self.probe_keys, seed=self.seed, num_steps=self.timesteps) self.assoc_output = np.zeros((1, self.dimension)) def build_output(self, model): assoc_probes = OrderedDict() threshold_probes = OrderedDict() assoc_spike_probes = OrderedDict() synapse = self.assoc_params.synapse with model: input = nengo.Node(output=self.assoc_output_func) output = EnsembleArray(n_neurons=self.neurons_per_dim, n_ensembles=self.dimension, label="output", radius=self.radius) nengo.Connection(input, output.input, synapse=synapse) self.output_probe = nengo.Probe(output.output, 'output', synapse=0.02) for k in self.probe_keys: n = nengo.Node(output=self.assoc_memory.probe_func(k)) probe = nengo.Probe(n, synapse=synapse) threshold_probes[k] = probe node = nengo.Node(output=self.assoc_memory.spike_func(k)) assoc_spike_probes[k] = nengo.Probe(node, synapse=None) self.assoc_probes = assoc_probes self.threshold_probes = threshold_probes self.assoc_spike_probes = assoc_spike_probes def extract(self, item, query, *args, **kwargs): self.print_instance_difficulty(item, query) then = datetime.datetime.now() self.A_input_vector = item self.B_input_vector = query print "Simulating unbind model" self.unbind_simulator.run(self.timesteps * self.dt) assoc_input = self.unbind_simulator.data[self.D_probe] print "Simulating associative memory" self.assoc_output = self.assoc_memory.multi_step(assoc_input) self.output_index = 0 print "Simulating output" self.output_simulator.run(self.timesteps * self.dt) now = datetime.datetime.now() self.write_to_runtime_file(now - then, "unbind") # for plotting self.data = {k: v for (k, v) in self.output_simulator.data.iteritems()} self.data[self.D_probe] = self.unbind_simulator.data[self.D_probe] self.data[self.input_probe] = \ self.unbind_simulator.data[self.input_probe] if self.plot: self.plot_simulation() vector = self.data[self.output_probe][-1, :] return [vector] def assoc_output_func(self, t): index = int(t / self.dt) return self.assoc_output[index] def reset_nodes(self): pass def write_to_runtime_file(self, delta, label=''): to_print = [self.dimension, self.num_items, self.neurons_per_item, self.neurons_per_dim, self.timesteps, "OCL: "+str(self.ocl), "GPUS: "+str(self.gpus), "fast", delta] print >> self.runtimes_file, label, \ ": " ",".join([str(tp) for tp in to_print]) def print_config(self, output_file): super(FastNeuralExtractor, self).print_config(output_file) output_file.write("Fast neural extractor config:\n")