def stop(self, turn_off_machine=None, clear_routing_tables=None, clear_tags=None): """ :param turn_off_machine: decides if the machine should be powered down\ after running the execution. Note that this powers down all boards\ connected to the BMP connections given to the transceiver :type turn_off_machine: bool :param clear_routing_tables: informs the tool chain if it\ should turn off the clearing of the routing tables :type clear_routing_tables: bool :param clear_tags: informs the tool chain if it should clear the tags\ off the machine at stop :type clear_tags: boolean :rtype: None """ # pylint: disable=protected-access for population in self._populations: population._end() super(AbstractSpiNNakerCommon, self).stop(turn_off_machine, clear_routing_tables, clear_tags) self.reset_number_of_neurons_per_core() globals_variables.unset_simulator()
def EvaluateModel(t_stim, testing_examples): current = multiprocessing.current_process() print('Started {}'.format(current)) f_name = "errorlog/" + current.name + "_stdout.txt" g_name = "errorlog/" + current.name + "_stderror.txt" f = open(f_name, 'w') g = open(g_name, 'w') old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = f sys.stderr = g from spinn_front_end_common.utilities import globals_variables globals_variables.unset_simulator() extra_args = ['lenet_dense_dt_01_not_normalised_serialised', '--t_stim', str(t_stim), '--testing_examples',\ str(testing_examples), '--result_filename', 'output_data_'+str(t_stim), '--result_dir', 'results',\ '--chunk_size', '200'] import pynn_object_serialisation.experiments.mnist_testing.mnist_testing as mnist_testing from pynn_object_serialisation.experiments.mnist_testing.mnist_argparser import parser new_args = parser.parse_args(extra_args) mnist_testing.run(new_args) sys.stdout = old_stdout sys.stderr = old_stderr print("Run for {} completed".format(t_stim)) return
def check_directory(self, path, skips=[], broken=[]): directory = os.path.join(self._introlab_dir, path) for a_script in os.listdir(directory): if a_script.endswith(".py"): if a_script in skips: continue script = os.path.join(directory, a_script) try: globals_variables.unset_simulator() plotting = "import matplotlib.pyplot" in open( script).read() if plotting: self.check_plotting_script(script) else: self.check_script(script) except Exception as ex: if "virtual machine" in str(ex): self.report(script, "scripts_fails_because_on_vm") elif "'ConnectionHolder'" in str(ex): self.report(script, "scripts_fails_because_on_vm") elif a_script in broken: self.report(script, "scripts_skipped_with_unkown_issues") else: print("Error on {}".format(script)) raise ex
def runsafe(self, method): retries = 0 last_error = None while retries < 3: try: method() return except JobDestroyedError as ex: class_file = sys.modules[self.__module__].__file__ with open(self.destory_path(), "a") as destroyed_file: destroyed_file.write(class_file) destroyed_file.write("\n") destroyed_file.write(str(ex)) destroyed_file.write("\n") last_error = ex retries += 1 globals_variables.unset_simulator() except SpinnmanException as ex: class_file = sys.modules[self.__module__].__file__ with open(self.spinnman_exception_path(), "a") as exc_file: exc_file.write(class_file) exc_file.write("\n") exc_file.write(str(ex)) exc_file.write("\n") last_error = ex retries += 1 globals_variables.unset_simulator() raise last_error
def test_rte_at_start(): globals_variables.unset_simulator() s.setup(model_binary_folder=os.path.dirname(__file__)) s.add_machine_vertex_instance( RunVertex("test_rte_start.aplx", ExecutableType.USES_SIMULATION_INTERFACE)) with pytest.raises(SpinnmanException): s.run(1000)
def check_directory(self, path): directory = os.path.join(self._introlab_dir, path) for a_script in os.listdir(directory): if a_script.endswith(".py"): globals_variables.unset_simulator() script = os.path.join(directory, a_script) try: self.check_script(script) except Exception as ex: print("Error on {}".format(script)) raise ex
def test_rte_during_run_forever(): globals_variables.unset_simulator() s.setup(model_binary_folder=os.path.dirname(__file__)) s.add_machine_vertex_instance( RunVertex("test_rte_during_run.aplx", ExecutableType.USES_SIMULATION_INTERFACE)) s.add_socket_address(None, "localhost", conn.local_port) s.run(None) conn.close() with pytest.raises(ExecutableFailedToStopException): s.stop()
def setUp(self): factor = random.random() if factor > p7_integration_factor: msg = "Test skipped by random number {} above " \ "P7_INTEGRATION_FACTOR {}" \ "".format(factor, p7_integration_factor) raise SkipTest(msg) globals_variables.unset_simulator() class_file = sys.modules[self.__module__].__file__ path = os.path.dirname(os.path.abspath(class_file)) os.chdir(path)
def setUp(self): # Remove random effect for testing # Set test_seed to None to allow random self._test_seed = 1 factor = random.random() if factor > p8_integration_factor: raise SkipTest("Test skipped by random number {} above " "P8_INTEGRATION_FACTOR {}".format( factor, p8_integration_factor)) globals_variables.unset_simulator() class_file = sys.modules[self.__module__].__file__ path = os.path.dirname(os.path.abspath(class_file)) os.chdir(path)
def check_extra_monitor(self): mbs = _TRANSFER_SIZE_MEGABYTES # setup system globals_variables.unset_simulator() sim.setup(model_binary_folder=os.path.dirname(__file__), n_chips_required=2) # build verts writer_vertex = SDRAMWriter(mbs) # add verts to graph sim.add_machine_vertex_instance(writer_vertex) sim.run(12) writer_placement = sim.placements().get_placement_of_vertex( writer_vertex) # pylint: disable=protected-access outputs = sim.globals_variables.get_simulator()._last_run_outputs monitor_vertices = outputs[_MONITOR_VERTICES] receiver_plt = _get_monitor_placement(monitor_vertices, writer_placement) gatherers, gatherer = _get_gatherer_for_monitor(writer_vertex) start = float(time.time()) data = _do_transfer(gatherer, gatherers, monitor_vertices, receiver_plt, writer_placement, writer_vertex) end = float(time.time()) print( "time taken to extract {} MB is {}. Transfer rate: {} Mb/s".format( mbs, end - start, (mbs * 8) / (end - start))) check_data(data) sim.stop()
def stop(self, turn_off_machine=None, clear_routing_tables=None, clear_tags=None): """ :param turn_off_machine: decides if the machine should be powered down\ after running the execution. Note that this powers down all boards\ connected to the BMP connections given to the transceiver :type turn_off_machine: bool :param clear_routing_tables: informs the tool chain if it\ should turn off the clearing of the routing tables :type clear_routing_tables: bool :param clear_tags: informs the tool chain if it should clear the tags\ off the machine at stop :type clear_tags: boolean :rtype: None """ # pylint: disable=protected-access for population in self._populations: population._end() super(AbstractSpiNNakerCommon, self).stop( turn_off_machine, clear_routing_tables, clear_tags) self.reset_number_of_neurons_per_core() globals_variables.unset_simulator()
def runsafe(self, method, retry_delay=3.0): retries = 0 while True: try: method() break except JobDestroyedError as ex: class_file = sys.modules[self.__module__].__file__ with open(self.destory_path(), "a") as destroyed_file: destroyed_file.write(class_file) destroyed_file.write("\n") destroyed_file.write(str(ex)) destroyed_file.write("\n") retries += 1 globals_variables.unset_simulator() if retries >= 3: raise ex except SpinnmanException as ex: class_file = sys.modules[self.__module__].__file__ with open(self.spinnman_exception_path(), "a") as exc_file: exc_file.write(class_file) exc_file.write("\n") exc_file.write(str(ex)) exc_file.write("\n") retries += 1 globals_variables.unset_simulator() if retries >= 3: raise ex print("") print("==========================================================") print(" Will run {} again in {} seconds".format( method, retry_delay)) print("retry: {}".format(retries)) print("==========================================================") print("") time.sleep(retry_delay)
def setUp(self): globals_variables.unset_simulator() class_file = sys.modules[self.__module__].__file__ path = os.path.dirname(os.path.abspath(class_file)) os.chdir(path)
def run(args, start_index): # Record SCRIPT start time (wall clock) start_time = plt.datetime.datetime.now() # Note that this won't be global between processes global try_number try_number += 1 globals_variables.unset_simulator() signal.signal(signal.SIGINT, signal_handler) current = multiprocessing.current_process() print('Started {}'.format(current) + '\n') f_name = "errorlog/" + current.name + "_stdout.txt" g_name = "errorlog/" + current.name + "_stderror.txt" f = open(f_name, 'w') g = open(g_name, 'w') old_stdout = sys.stdout old_stderr = sys.stderr # sys.stdout = f # sys.stderr = g N_layer = 28**2 # number of neurons in input population t_stim = args.t_stim (x_train, y_train), (x_test, y_test) = mnist.load_data() # reshape input to flatten data x_test = x_test.reshape(x_test.shape[0], np.prod(x_test.shape[1:])) testing_examples = args.chunk_size simtime = testing_examples * t_stim range_of_slots = np.arange(testing_examples) starts = np.ones((N_layer, testing_examples)) * (range_of_slots * t_stim) durations = np.ones((N_layer, testing_examples)) * t_stim rates = x_test[start_index:start_index + args.chunk_size, :].T y_test = y_test[start_index:start_index + args.chunk_size] # scaling rates _0_to_1_rates = rates / float(np.max(rates)) rates = _0_to_1_rates * args.rate_scaling input_params = {"rates": rates, "durations": durations, "starts": starts} print("Number of testing examples to use:", testing_examples) print("Min rate", np.min(rates)) print("Max rate", np.max(rates)) print("Mean rate", np.mean(rates)) replace = None timestep = args.timestep timescale = args.time_scale_factor output_v = [] sim.setup(timestep, timestep, timestep, time_scale_factor=timescale) print("Setting number of neurons per core...") sim.set_number_of_neurons_per_core(SpikeSourcePoissonVariable, 16) sim.set_number_of_neurons_per_core(sim.SpikeSourcePoisson, 16) sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 64) sim.set_number_of_neurons_per_core(sim.IF_cond_exp, 64) print("Restoring populations and projections...") populations, projections, extra_params = restore_simulator_from_file( sim, args.model, input_type='vrpss', vrpss_cellparams=input_params, replace_params=replace) def add_correlation_population(sim, populations, projections): print("Adding a input/output correlation population...") #Define neuron model for population (long intergration time) propably the same as the others corr_neuron_model_params = populations[1].celltype.default_parameters input_size = populations[0].size # Make a population that correlates input and output corr_pop = sim.Population(input_size, cellclass=sim.IF_cond_exp(), label='corr_pop') # Add it to populations populations.append(corr_pop) #Weight for just one spike low_weight = 0.01 weight = 0.1 #Proj from input (remember delay) #Add to projections projections.append( sim.Projection(populations[0], corr_pop, sim.OneToOneConnector(), sim.StaticSynapse(weight=low_weight, delay=len(populations) - 1), receptor_type='excitatory')) #Proj from output classes #Add to projections from_list = [(7, x, weight, 0) for x in range(input_size)] projections.append( sim.Projection(populations[-2], corr_pop, sim.FromListConnector(from_list), receptor_type='excitatory')) return populations, projections populations, projections = add_correlation_population( sim, populations, projections) old_runtime = extra_params['simtime'] if 'simtime' in extra_params else None print("Setting i_offsets...") set_i_offsets(populations, simtime, old_runtime=old_runtime) spikes_dict = {} neo_spikes_dict = {} current_error = None final_connectivity = {} def reset_membrane_voltage(): #This doesn't work see SpyNNaker8 GitHub issue #331 use set_initial_value branches for population in populations[1:]: population.set_initial_value(variable="v", value=0) return for pop in populations[:]: pop.record("spikes") if args.record_v: populations[-1].record("v") sim_start_time = plt.datetime.datetime.now() if not args.reset_v: print('Presenting examples {}:{}'.format( start_index, start_index + testing_examples)) sim.run(simtime) for i in range(args.chunk_size): print('Presenting example {}/{}'.format(start_index + i, testing_examples)) sim.run(t_stim) reset_membrane_voltage() # Compute time taken to reach this point end_time = plt.datetime.datetime.now() total_time = end_time - start_time sim_total_time = end_time - sim_start_time for pop in populations[:]: spikes_dict[pop.label] = pop.spinnaker_get_data('spikes') if args.record_v: output_v = populations[-1].spinnaker_get_data('v') #The following can take a long time and so is added through a flag if args.retrieve_connectivity: try: for proj in projections: try: final_connectivity[proj.label] = \ np.array(proj.get(('weight', 'delay'), format="list")._get_data_items()) except AttributeError as ae: print( "Careful! Something happened when retrieving the " "connectivity:", ae, "\nRetrying using standard PyNN syntax...") final_connectivity[proj.label] = \ np.array(proj.get(('weight', 'delay'), format="list")) except TypeError as te: print("Connectivity is None (", te, ") for connection", proj.label) print("Connectivity as empty array.") final_connectivity[proj.label] = np.array([]) except: traceback.print_exc() print("Couldn't retrieve connectivity.") if args.result_filename: results_filename = args.result_filename else: results_filename = "mnist_results" if args.suffix: results_filename += args.suffix else: pass # Retrieve simulation parameters for provenance tracking and debugging purposes sim_params = { "argparser": vars(args), "git_hash": retrieve_git_commit(), "run_end_time": end_time.strftime("%H:%M:%S_%d/%m/%Y"), "wall_clock_script_run_time": str(total_time), "wall_clock_sim_run_time": str(sim_total_time), } results_file = os.path.join( os.path.join(args.result_dir, results_filename + "_" + str(start_index))) np.savez_compressed(results_file, output_v=output_v, neo_spikes_dict=neo_spikes_dict, all_spikes=spikes_dict, all_neurons=extra_params['all_neurons'], testing_examples=testing_examples, N_layer=N_layer, no_testing_examples=testing_examples, num_classes=10, y_test=y_test, input_params=input_params, input_size=N_layer, simtime=simtime, t_stim=t_stim, sim_params=sim_params, final_connectivity=final_connectivity, init_connectivity=extra_params['all_connections'], extra_params=extra_params, current_error=current_error) sim.end() # Analysis time! post_run_analysis(filename=results_file, fig_folder=args.result_dir + args.figures_dir) # Report time taken print("Results stored in -- " + results_filename) # Report time taken print("Total time elapsed -- " + str(total_time)) return current_error
def breakout_test(connections, arms, split=4, runtime=2000, exposure_time=200, noise_rate=100, noise_weight=0.01, reward=0, spike_f=False, seed=0): np.random.seed(seed) sleep = 10 * np.random.random() time.sleep(sleep) max_attempts = 2 try_except = 0 while try_except < max_attempts: bandit = [] bandit_count = -1 excite = [] excite_count = -1 excite_marker = [] inhib = [] inhib_count = -1 inhib_marker = [] failures = [] try: p.setup(timestep=1.0, min_delay=1, max_delay=127) p.set_number_of_neurons_per_core(p.IF_cond_exp, 100) except: print "set up failed, trying again" try: p.setup(timestep=1.0, min_delay=1, max_delay=127) p.set_number_of_neurons_per_core(p.IF_cond_exp, 100) except: print "set up failed, trying again for the last time" p.setup(timestep=1.0, min_delay=1, max_delay=127) p.set_number_of_neurons_per_core(p.IF_cond_exp, 100) # starting_pistol = p.Population(len(arms), p.SpikeSourceArray(spike_times=[0])) for i in range(len(connections)): [in2e, in2i, e_size, e2e, e2i, i_size, i2e, i2i, e2out, i2out] = connections[i] if (len(in2e) == 0 and len(in2i) == 0) or (len(e2out) == 0 and len(i2out) == 0): failures.append(i) print "agent {} was not properly connected to the game".format(i) else: bandit_count += 1 bandit.append( p.Population(len(arms), spinn_breakout.Breakout(x_factor=x_factor, y_factor=y_factor, label="breakout {}".format(i)))) if e_size > 0: excite_count += 1 excite.append( p.Population(e_size, p.IF_cond_exp(), label='excite_pop_{}-{}'.format(excite_count, i))) excite_noise = p.Population(e_size, p.SpikeSourcePoisson(rate=noise_rate)) p.Projection(excite_noise, excite[excite_count], p.OneToOneConnector(), p.StaticSynapse(weight=noise_weight), receptor_type='excitatory') if spike_f: excite[excite_count].record('spikes') excite_marker.append(i) if i_size > 0: inhib_count += 1 inhib.append(p.Population(i_size, p.IF_cond_exp(), label='inhib_pop_{}-{}'.format(inhib_count, i))) inhib_noise = p.Population(i_size, p.SpikeSourcePoisson(rate=noise_rate)) p.Projection(inhib_noise, inhib[inhib_count], p.OneToOneConnector(), p.StaticSynapse(weight=noise_weight), receptor_type='excitatory') if spike_f: inhib[inhib_count].record('spikes') inhib_marker.append(i) if len(in2e) != 0: p.Projection(bandit[bandit_count], excite[excite_count], p.FromListConnector(in2e), receptor_type='excitatory') # p.Projection(starting_pistol, excite[excite_count], p.FromListConnector(in2e), # receptor_type='excitatory') if len(in2i) != 0: p.Projection(bandit[bandit_count], inhib[inhib_count], p.FromListConnector(in2i), receptor_type='excitatory') # p.Projection(starting_pistol, inhib[inhib_count], p.FromListConnector(in2i), # receptor_type='excitatory') if len(e2e) != 0: p.Projection(excite[excite_count], excite[excite_count], p.FromListConnector(e2e), receptor_type='excitatory') if len(e2i) != 0: p.Projection(excite[excite_count], inhib[inhib_count], p.FromListConnector(e2i), receptor_type='excitatory') if len(i2e) != 0: p.Projection(inhib[inhib_count], excite[excite_count], p.FromListConnector(i2e), receptor_type='inhibitory') if len(i2i) != 0: p.Projection(inhib[inhib_count], inhib[inhib_count], p.FromListConnector(i2i), receptor_type='inhibitory') if len(e2out) != 0: p.Projection(excite[excite_count], bandit[bandit_count], p.FromListConnector(e2out), receptor_type='excitatory') if len(i2out) != 0: p.Projection(inhib[inhib_count], bandit[bandit_count], p.FromListConnector(i2out), receptor_type='inhibitory') simulator = get_simulator() try: p.run(runtime) try_except = max_attempts break except: traceback.print_exc() try: globals_variables.unset_simulator() print "end was necessary" except: traceback.print_exc() print "end wasn't necessary" try_except += 1 print "failed to run on attempt ", try_except, "\n" # . total fails: ", all_fails, "\n" if try_except >= max_attempts: print "calling it a failed population, splitting and rerunning" return 'fail' scores = [] agent_fitness = [] fails = 0 excite_spike_count = [0 for i in range(len(connections))] excite_fail = 0 inhib_spike_count = [0 for i in range(len(connections))] inhib_fail = 0 print "reading the spikes of ", config for i in range(len(connections)): print "started processing fitness of: ", i if i in failures: print "worst score for the failure" fails += 1 scores.append([[max_fail_score], [max_fail_score], [max_fail_score], [max_fail_score]]) # agent_fitness.append(scores[i]) excite_spike_count[i] -= max_fail_score inhib_spike_count[i] -= max_fail_score else: if spike_f: if i in excite_marker: print "counting excite spikes" spikes = excite[i - excite_fail - fails].get_data('spikes').segments[0].spiketrains for neuron in spikes: for spike in neuron: excite_spike_count[i] += 1 else: excite_fail += 1 print "had an excite failure" if i in inhib_marker: print "counting inhib spikes" spikes = inhib[i - inhib_fail - fails].get_data('spikes').segments[0].spiketrains for neuron in spikes: for spike in neuron: inhib_spike_count[i] += 1 else: inhib_fail += 1 print "had an inhib failure" scores.append(get_scores(game_pop=bandit[i - fails], simulator=simulator)) # pop[i].stats = {'fitness': scores[i][len(scores[i]) - 1][0]} # , 'steps': 0} print "finished spikes" if spike_f: agent_fitness.append([scores[i][len(scores[i]) - 1][0], excite_spike_count[i] + inhib_spike_count[i]]) else: agent_fitness.append(scores[i][len(scores[i]) - 1][0]) # print i, "| e:", excite_spike_count[i], "-i:", inhib_spike_count[i], "|\t", scores[i] print "The scores for this run of {} agents are:".format(len(connections)) for i in range(len(connections)): print "c:{}, s:{}, si:{}, si0:{}".format(len(connections), len(scores), len(scores[i]), len(scores[i][0])) e_string = "e: {}".format(excite_spike_count[i]) i_string = "i: {}".format(inhib_spike_count[i]) score_string = "" for j in range(len(scores[i])): score_string += "{:4},".format(scores[i][j][0]) print "{:3} | {:8} {:8} - ".format(i, e_string, i_string), score_string p.end() return agent_fitness
def setUp(self): globals_variables.unset_simulator()
def run(args, start_index): # Record SCRIPT start time (wall clock) start_time = plt.datetime.datetime.now() # Note that this won't be global between processes global try_number try_number += 1 globals_variables.unset_simulator() signal.signal(signal.SIGINT, signal_handler) current = multiprocessing.current_process() print('Started {}'.format(current) + '\n') f_name = "errorlog/" + current.name + "_stdout.txt" g_name = "errorlog/" + current.name + "_stderror.txt" f = open(f_name, 'w') g = open(g_name, 'w') old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = f sys.stderr = g # Checking directory structure exists if not os.path.isdir(args.result_dir) and not os.path.exists( args.result_dir): os.mkdir(args.result_dir) # Load data from file x_test = np.load(args.data_dir + "x_test.npz")['arr_0'] y_test = np.load(args.data_dir + "y_test.npz")['arr_0'] if args.shuffle_data: assert len(x_test) == len(y_test) p = np.random.permutation(len(y_test)) x_test = x_test[p] y_test = y_test[p] if args.testing_examples == 1: index = np.argwhere(y_test == args.label_to_test)[0] x_test = x_test[index] y_test = y_test[index] max_rate = args.rate_scaling if args.prescaled_data: max_rate = 1 input_params = convert_rate_array_to_VRPSS(x_test[start_index:start_index + args.testing_examples], max_rate=max_rate, duration=args.t_stim) timestep = args.timestep timescale = args.time_scale_factor output_v = [] sim.setup(timestep, timestep, timestep, time_scale_factor=timescale) print("Setting number of neurons per core...") sim.set_number_of_neurons_per_core(SpikeSourcePoissonVariable, 16) sim.set_number_of_neurons_per_core(sim.SpikeSourcePoisson, 16) sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 16) sim.set_number_of_neurons_per_core(sim.IF_cond_exp, 16) sim.set_number_of_neurons_per_core(sim.IF_curr_delta, 16) v_reset = 0 replace = { 'v_thresh': args.v_thresh, 'tau_refrac': 0, 'v_reset': v_reset, 'v_rest': 0, 'v': 0, 'cm': 1, 'tau_m': 1000, 'tau_syn_E': 0.02, 'tau_syn_I': 0.02, 'delay': 0 } populations, projections, extra_params = restore_simulator_from_file( sim, os.path.join(args.root_dir, args.model), input_type='vrpss', is_input_vrpss=True, vrpss_cellparams=input_params, replace_params=replace, delta_input=args.delta) dt = sim.get_time_step() simtime = args.testing_examples * args.t_stim N_layer = len(populations) min_delay = sim.get_min_delay() max_delay = sim.get_max_delay() sim.set_number_of_neurons_per_core(SpikeSourcePoissonVariable, 16) sim.set_number_of_neurons_per_core(sim.SpikeSourcePoisson, 16) sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 16) sim.set_number_of_neurons_per_core(sim.IF_cond_exp, 16) sim.set_number_of_neurons_per_core(sim.IF_curr_delta, 16) old_runtime = extra_params['simtime'] if 'simtime' in extra_params else None #set_i_offsets(populations, runtime, old_runtime=old_runtime) set_zero_i_offsets(populations) spikes_dict = {} output_v = [] neo_spikes_dict = {} def record_output(populations, offset, output): spikes = populations[-1].spinnaker_get_data('spikes') spikes = spikes + [0, offset] name = populations[-1].label if np.shape(spikes)[0] > 0: if name in list(output.keys()): output[name] = np.concatenate((output, spikes)) else: output[name] = spikes return output for pop in populations[:]: pop.record("spikes") if args.record_v: populations[-1].record("v") def reset_membrane_voltage(v_reset): for population in populations[1:]: population.set_initial_value(variable="v", value=v_reset) return sim_start_time = plt.datetime.datetime.now() for presentation in range(args.chunk_size): print("Presenting test example {}".format(presentation)) sim.run(args.t_stim) reset_membrane_voltage(v_reset) # Compute time taken to reach this point end_time = plt.datetime.datetime.now() total_time = end_time - start_time sim_total_time = end_time - sim_start_time for pop in populations[:]: spikes_dict[pop.label] = pop.spinnaker_get_data('spikes') if args.record_v: output_v = populations[-1].spinnaker_get_data('v') sim_params = {"argparser": vars(args)} # save results result_filename = get_result_filename(args, start_index) np.savez_compressed(result_filename, output_v=output_v, neo_spikes_dict=neo_spikes_dict, all_spikes=spikes_dict, all_neurons=extra_params['all_neurons'], testing_examples=args.testing_examples, N_layer=N_layer, no_testing_examples=args.testing_examples, num_classes=10, y_test=y_test, start_index=start_index, chunk_size=args.chunk_size, input_params=input_params, input_size=N_layer, simtime=simtime, t_stim=args.t_stim, timestep=timestep, time_scale_factor=timescale, sim_params=sim_params, init_connectivity=extra_params['all_connections'], extra_params=extra_params) sim.end()