def simulate(self):
"""
Create the network and execute simulation.
Record used memory and wallclock time.
"""
t0 = time.time()
self.base_memory = self.memory()
self.prepare()
t1 = time.time()
self.time_prepare = t1 - t0
print("Prepared simulation in {0:.2f} seconds.".format(
self.time_prepare))
self.create_recording_devices()
self.create_areas()
t2 = time.time()
self.time_network_local = t2 - t1
print("Created areas and internal connections in {0:.2f} seconds.".
format(self.time_network_local))
self.cortico_cortical_input()
t3 = time.time()
self.network_memory = self.memory()
self.time_network_global = t3 - t2
print(
"Created cortico-cortical connections in {0:.2f} seconds.".format(
self.time_network_global))
self.save_network_gids()
print("Network size:", nest.GetKernelStatus('network_size'))
print("Saved network in {0:2f} seconds.".format(time.time() - t3))
t4 = time.time()
nest.Prepare()
nest.Run(10.)
self.time_init = time.time() - t4
self.init_memory = self.memory()
print("Init time in {0:.2f} seconds.".format(self.time_init))
t5 = time.time()
#nest.Simulate(self.T)
nest.Run(self.T)
nest.Cleanup()
t6 = time.time()
self.time_simulate = t6 - t5
self.total_memory = self.memory()
print("Simulated network in {0:.2f} seconds.".format(
self.time_simulate))
self.logging()
def RunSimulation():
nest.set_verbosity(M_INFO)
logger = Logger()
logger.log('{} # virt_mem_0'.format(memory_thisjob()))
# ----------------------- Network Construction -----------------------------
BuildNetwork(logger)
# ---------------- Initial simulation: rig and calibrate -------------------
tic = time.time()
nest.Prepare()
nest.Run(params['inisimtime'])
InitializationTime = time.time() - tic
logger.log('{} # init_time'.format(InitializationTime))
logger.log('{} # virt_mem_after_init'.format(memory_thisjob()))
# ----------------------- Cleanup and output -------------------------------
nest.Cleanup()
logger.log('{} # num_neurons'.format(logger_params['num_nodes']))
logger.log('{} # num_connections'.format(
nest.GetKernelStatus('num_connections')))
logger.log('{} # min_delay'.format(nest.GetKernelStatus('min_delay')))
logger.log('{} # max_delay'.format(nest.GetKernelStatus('max_delay')))
def simulate(self, dvs_data, reward_conditional, reward_collision,
area_left, area_right, test):
for synapse in self.conn_l:
weight = nest.GetStatus([synapse], keys="weight")[0]
nest.SetStatus(
[synapse], {
"n": (reward_conditional - reward_collision) * weight *
p.reward_factor * 0.0001
})
for synapse in self.conn_r:
weight = nest.GetStatus([synapse], keys="weight")[0]
nest.SetStatus(
[synapse], {
"n":
-(reward_conditional + reward_collision) * weight *
p.reward_factor * 0.0001
})
time = nest.GetKernelStatus("time")
#
# nest.SetStatus(self.spike_generators_left, {"origin": time})
# nest.SetStatus(self.spike_generators_left, {"stop": p.sim_time})
# nest.SetStatus(self.spike_generators_right, {"origin": time})
# nest.SetStatus(self.spike_generators_right, {"stop": p.sim_time})
nest.SetStatus(self.spike_generators, {"origin": time})
nest.SetStatus(self.spike_generators, {"stop": p.sim_time})
dvs_data = dvs_data.reshape(dvs_data.size)
for i in range(dvs_data.size):
rate = dvs_data[i] / p.max_spikes
rate = np.clip(rate, 0, 1) * p.max_poisson_freq
nest.SetStatus([self.spike_generators[i]], {"rate": rate})
# if i < 16:
# nest.SetStatus([self.spike_generators_left[i]], {"rate": rate})
# else:
# nest.SetStatus([self.spike_generators_right[i % 16]], {"rate": rate})
if test:
nest.Prepare()
nest.Run(p.sim_time)
nest.Cleanup()
else:
nest.Simulate(p.sim_time)
n_l = nest.GetStatus(self.spike_detector, keys="n_events")[0]
n_r = nest.GetStatus(self.spike_detector, keys="n_events")[1]
nest.SetStatus(self.spike_detector, {"n_events": 0})
weights_l = np.array(nest.GetStatus(
self.conn_l, keys="weight")).reshape(p.resolution)
weights_r = np.array(nest.GetStatus(
self.conn_r, keys="weight")).reshape(p.resolution)
# weights_l = np.array(nest.GetStatus(self.conn_l, keys="weight")).reshape(4,4)
# weights_r = np.array(nest.GetStatus(self.conn_r, keys="weight")).reshape(4,4)
return n_l, n_r, weights_l, weights_r
def simulate_mpi_co_simulation(time_synch, end, logger):
"""
simulation with co-simulation
:param time_synch: time of synchronization between all the simulator
:param end : time of end simulation
:param logger : logger simulation
"""
# Simulation
count = 0.0
logger.info("Nest Prepare")
nest.Prepare()
while count * time_synch < end: # FAT END POINT
logger.info(" Nest run time " + str(nest.GetKernelStatus('time')))
nest.Run(time_synch)
logger.info(" Nest end")
count += 1
logger.info("cleanup")
nest.Cleanup()
logger.info("finish")
return
def run(self, dvs_data):
"""Run the SNN (use this for testing as weights are not changed)."""
# Set poisson neuron firing time span
time = nest.GetKernelStatus("time")
nest.SetStatus(self.spike_generators, {"origin": time})
nest.SetStatus(self.spike_generators, {"stop": params.sim_time})
# Set poisson neuron firing frequency
dvs_data = dvs_data.reshape(dvs_data.size)
for i in range(dvs_data.size):
rate = dvs_data[i] / params.max_spikes
rate = np.clip(rate, 0, 1) * params.max_poisson_freq
nest.SetStatus([self.spike_generators[i]], {"rate": rate})
# Run network in NEST
nest.Prepare()
nest.Run(params.sim_time)
nest.Cleanup()
# Get left and right output spikes
n_l = nest.GetStatus(self.spike_detector, keys="n_events")[0]
n_r = nest.GetStatus(self.spike_detector, keys="n_events")[1]
# Reset output spike detector
nest.SetStatus(self.spike_detector, {"n_events": 0})
return n_l, n_r
def run(self, stim=0, stim_rate=0.5, stim_tim=5000, n_trials=1):
"""run the simulation
Chunk - to prevent from running unnecessary
stim - with extra Poiss inoput"""
# print("Simulating")
# Simulate in chunk and check a special condition in between
# Thus we avoid unwanted condition
if self.chunk and stim != 1:
nest.Prepare()
self.chunk_times = np.arange(0, self.simtime + 1,
self.chunk_size)[1::]
if len(self.chunk_times) != int(self.simtime / self.chunk_size):
raise ChunkError('check the simulation length')
for ch in self.chunk_times:
nest.Run(self.chunk_size)
self.events_ex = nest.GetStatus(self.espikes, "n_events")[0]
self.rate_ex = self.events_ex / ch * 1000.0 / self.N_rec
if self.rate_ex > 200.0:
#if self.verbose:
print('rate is ', self.rate_ex)
print('Rate is too high. Finishing simulation at %s ms' %
(self.chunk_size))
self.simtime = ch #self.chunk_size
break
nest.Cleanup()
elif stim == 1:
self.nu_th = self.theta / (
self.J * self.KE * self.tauMem
) ## (theta * CMem) / (J_ex * CE * exp(1) * tauMem * tauSyn)
#self.new_nu_ex = stim_eta * self.nu_th
self.new_p_rate = stim_rate
self.add_noise = nest.Create("poisson_generator")
nest.Simulate(self.simtime)
nest.SetStatus(self.add_noise, {"rate": self.new_p_rate})
nest.Connect(self.add_noise,
self.nodes_ex[:100],
syn_spec=self.syn_dict)
#nest.Connect(self.add_noise,self.nodes_in[:100], syn_spec=self.syn_dict)
for trial in range(n_trials):
nest.SetStatus(self.add_noise, {"rate": self.new_p_rate})
nest.Simulate(stim_tim)
nest.SetStatus(self.add_noise, {"rate": 0.0})
nest.Simulate(10000)
else:
#nest.Simulate(self.simtime)
nest.Prepare()
nest.Run(self.simtime)
nest.Cleanup()
if self.verbose:
self.events_ex = nest.GetStatus(self.espikes, "n_events")[0]
#self.events_in = nest.GetStatus(self.ispikes,"n_events")[0]
self.rate_ex = self.events_ex / self.simtime * 1000.0 / self.N_rec
#self.rate_in = self.events_in/self.simtime*1000.0/self.N_rec
self.num_synapses = (
nest.GetDefaults("excitatory")["num_connections"] +
nest.GetDefaults("inhibitory")["num_connections"] +
nest.GetDefaults("external")["num_connections"])
print("Brunel network simulation (Python)")
print("Number of neurons : {0}".format(self.N))
print("Number of synapses: {0}".format(self.num_synapses))
print(" Exitatory : {0}".format(
int(self.KE * self.N) + self.N))
print(" Inhibitory : {0}".format(int(self.KI * self.N)))
print("Rate : %.2f Hz" % self.rate_ex)
#print("Inhibitory rate : %.2f Hz" % self.rate_in)
print("Simulation time : %.2f s" % self.simtime)
# Creation of current generator
dc = nest.Create("dc_generator", params={"amplitude": 900.0})
dc_2 = nest.Create("dc_generator", params={"amplitude": 1000.0})
print("create nodes")
# Creation of connections
nest.Connect(s_ex, n, syn_spec={"weight": 1000.0})
nest.Connect(s_in, n_2, syn_spec={"weight": 1000.0})
nest.Connect(n, m)
nest.Connect(n_2, m)
nest.Connect(s_ex, m_2)
nest.Connect(s_in, m_2)
nest.Connect(n, m_3)
nest.Connect(n_2, m_3)
nest.Connect(s_ex, m_4)
nest.Connect(s_in, m_4)
print("create connect")
'''
A network simulation with a duration of 5*100 ms is started.
'''
print("Spike generator 1 {} and 2 {}".format(s_in, s_ex))
nest.Prepare()
print("Start run")
nest.Run(200.)
nest.Run(200.)
nest.Run(200.)
nest.Run(200.)
nest.Cleanup()
# print result
print(nest.GetStatus(m_3)[0]['events'])
print(nest.GetStatus(m_4)[0]['events'])
if len(args) > 1:
scale = int(args[1])
totVPs = int(args[2])
else:
scale = 0.1
totVPs = 4
print("scale: ", scale)
print("totVPs: ", totVPs)
if __name__ == '__main__':
nest.SetKernelStatus({'total_num_virtual_procs': totVPs})
pops = CreatePopulations(scale)
ConnectAll(pops)
# Init time and memory
tic = time.time()
nest.Prepare()
nest.Run(10.)
InitializationTime = time.time() - tic
print('{} # init_time'.format(InitializationTime))
print('{} # virt_mem_after_init'.format(
nest.ll_api.sli_func('memory_thisjob')))
print('{} # virt_mem_after_sim'.format(
nest.ll_api.sli_func(
'memory_thisjob'))) # No simulation, just here for consistency
def runs(self):
with nest.RunManager():
for _ in range(self.steps):
nest.Run(self.time)
# This loop runs over the `n_trials` trials and performs a standard protocol
# of a high-rate response, followed by a pause and then a recovery response.
#
# We actually run over ``n_trials + 1`` rounds, since the first trial is for
# equilibration and is not recorded (see voltmeter parameters above).
#
# We use the NEST ``:class:.RunManager`` to improve performance and call ``:func:.Run``
# inside for each part of the simulation.
#
# We print a line of breadcrumbs to indicate progress.
print(f"Simulating {n_trials} times ", end="", flush=True)
with nest.RunManager():
for t in range(n_trials + 1):
pre_neuron.I_e = I_stim
nest.Run(T_on)
pre_neuron.I_e = 0.0
nest.Run(T_off)
if t % 10 == 0:
print(".", end="", flush=True)
print()
###############################################################################
# Simulate one additional time step. This ensures that the
# voltage traces for all trials, including the last, have the full length, so we
# can easily transform them into a matrix below.
nest.Simulate(nest.resolution)
###############################################################################
def create_network(
path,
nb_VP,
nb_mpi,
nb_run,
time_sim,
spike_generator=0,
parrot=0,
iaf=0,
nb_mpi_recorder=0,
separate=False,
nb_mpi_generator_spike=0,
nb_mpi_generator_current=0,
shared_mpi_input=False,
mix_mpi=0,
):
"""
configure Nest for the testing part
:param path: path for saving sim
:param nb_VP: number of virtual processing
:param nb_mpi: number of MPI rank
:param nb_run: number of run
:param time_sim: time of 1 run
:param spike_generator: number of devices
:param parrot: number of parrot neurons
:param iaf: number of model of neurons
:param nb_mpi_recorder: number of MPI recording
:param separate: boolean for the separation of not of the reference
:param nb_mpi_generator_spike: number of mpi generator spike
:param nb_mpi_generator_current: number of mpi current
:param shared_mpi_input: shared of the mpi run ( need to valide the test )
:param mix_mpi: different case #TODO not yet implemented : creation of network where mpi input and output are connected
:return:
"""
print(nb_VP, nb_run, time_sim, spike_generator, parrot, iaf,
nb_mpi_recorder, separate, nb_mpi_generator_spike,
nb_mpi_generator_current, shared_mpi_input, mix_mpi)
sys.stdout.flush()
# name of the test
name = "nb_VP_"+str(nb_VP)+"nb_mpi"+str(nb_mpi)\
+'_D_'+str(int(spike_generator))+'_P_'+str(int(parrot))+'_N_'+str(int(iaf))\
+'_R_'+str(nb_mpi_recorder)+'_Separate_'+str(int(separate))\
+'_GS_'+str(nb_mpi_generator_spike) +'_GC_'+str(nb_mpi_generator_current)\
+'_SH_'+str(int(shared_mpi_input))+'_SM_'+str(mix_mpi)
logger = create_logger(
path + '/log/', name='nest_' +
str(nest.Rank())) # TODO need to use it for the degging part
nest.ResetKernel()
nest.SetKernelStatus({
"overwrite_files": True,
"data_path": path,
"total_num_virtual_procs": nb_VP,
})
# compute index and nb element for distinguish the different tests
nb_element = int(parrot > 0) + int(spike_generator > 0) + int(iaf > 0)
if nb_element == 0:
raise Exception('Miss the configuration ' + str(nb_element))
if shared_mpi_input:
if nb_mpi_recorder != 0 and nb_mpi_recorder % nb_element != 0:
raise Exception('Miss nb recorder')
if nb_mpi_generator_spike != 0 and nb_mpi_generator_spike % nb_element != 0:
raise Exception('Miss nb spike generator')
if nb_mpi_generator_current != 0 and nb_mpi_generator_current % nb_element != 0:
raise Exception('Miss nb current generator')
index_parrot = -2
index_device = -2
index_aif = -2
else:
if parrot > 0:
index_parrot = 0
if spike_generator > 0:
index_device = 1
if iaf > 0:
index_aif = 2
else:
index_aif = -1
else:
index_device = -1
if iaf > 0:
index_aif = 1
else:
index_aif = -1
else:
index_parrot = -1
if spike_generator > 0:
index_device = 0
if iaf > 0:
index_aif = 1
else:
index_aif = -1
else:
index_device = -1
if iaf > 0:
index_aif = 0
else:
index_aif = -1
#create mpi device
recorders = []
generator_spike = []
generator_current = []
for i in range(nb_mpi_recorder):
recorders.append(
nest.Create("spike_recorder",
params={
"record_to": "mpi",
"label": "file_record"
}))
for i in range(nb_mpi_generator_spike):
generator_spike.append(
nest.Create("spike_generator",
params={
"spike_times": np.array([]),
'stimulus_source': 'mpi',
"label": "file_gen_spike"
}))
for i in range(nb_mpi_generator_current):
generator_current.append(
nest.Create("step_current_generator",
params={
'amplitude_times': np.array([]),
'amplitude_values': np.array([]),
'stimulus_source': 'mpi',
"label": "file_gen_current"
}))
# particular device
poisson_generator = None
if parrot > 0 and nb_mpi_recorder > 0:
poisson_generator = nest.Create("poisson_generator")
# recorder
recorders_twins = []
recorder_parrot = []
recorder_device = []
recorder_neuron = []
for i in range(nb_mpi_recorder):
recorders_twins.append(
nest.Create("spike_recorder", params={"record_to": "memory"}))
if parrot > 0:
if (index_parrot != -1
and i % nb_element == index_parrot) or index_parrot == -2:
recorder_parrot.append(nest.Create('parrot_neuron', parrot))
nest.Connect(poisson_generator, recorder_parrot[-1])
nest.Connect(recorder_parrot[-1], recorders[i])
nest.Connect(recorder_parrot[-1], recorders_twins[i])
if spike_generator > 0:
if (index_device != -1
and i % nb_element == index_device) or index_device == -2:
np.random.seed(recorders[i].tolist()[0])
recorder_device.append(
nest.Create("spike_generator", spike_generator))
for j in range(spike_generator):
recorder_device[-1][j].set({
"spike_times":
np.around(np.sort(
np.random.rand(100) * time_sim * nb_run),
decimals=1).tolist()
})
nest.Connect(recorder_device[-1], recorders[i])
if separate:
np.random.seed(recorders[i].tolist()[0])
new_generator = nest.Create("spike_generator",
spike_generator)
for j in range(spike_generator):
new_generator[j].set({
"spike_times":
np.around(np.sort(
np.random.rand(100) * time_sim * nb_run),
decimals=1).tolist()
})
nest.Connect(new_generator, recorders_twins[i])
else:
nest.Connect(recorder_device[-1], recorders_twins[i])
if iaf > 0:
if (index_aif != -1
and i % nb_element == index_aif) or index_aif == -2:
recorder_neuron.append(nest.Create('iaf_psc_alpha', iaf))
nest.Connect(poisson_generator, recorder_neuron[-1])
nest.Connect(recorder_neuron[-1], recorders[i])
nest.Connect(recorder_neuron[-1], recorders_twins[i])
# generator spike
generator_spike_twin = []
generator_spike_parrot = []
generator_spike_parrot_bis = None
if separate:
generator_spike_parrot_bis = []
generator_spike_device = []
generator_spike_device_bis = None
if separate:
generator_spike_device_bis = []
generator_spike_neuron = []
generator_spike_neuron_bis = None
if separate:
generator_spike_neuron_bis = []
for i in range(nb_mpi_generator_spike):
data = generate_spike(generator_spike[i].tolist()[0], nb_run,
time_sim)[1]
data = np.concatenate(data).tolist()
generator_spike_twin.append(
nest.Create("spike_generator", params={"spike_times": data}))
if parrot > 0:
if (index_parrot != -1
and i % nb_element == index_parrot) or index_parrot == -2:
new_parrot = nest.Create('parrot_neuron', parrot)
generator_spike_parrot.append(
nest.Create("spike_recorder",
params={"record_to": "memory"}))
nest.Connect(generator_spike[i], new_parrot)
nest.Connect(new_parrot, generator_spike_parrot[-1])
if separate:
new_parrot_2 = nest.Create('parrot_neuron', parrot)
generator_spike_parrot_bis.append(
nest.Create("spike_recorder",
params={"record_to": "memory"}))
nest.Connect(generator_spike_twin[i], new_parrot_2)
nest.Connect(new_parrot_2, generator_spike_parrot_bis[-1])
else:
nest.Connect(generator_spike_twin[i], new_parrot)
if spike_generator > 0:
if (index_device != -1
and i % nb_element == index_device) or index_device == -2:
np.random.seed(generator_spike[-1].tolist()[0])
generator_spike_device.append(
nest.Create("spike_recorder", spike_generator))
nest.Connect(generator_spike[i], generator_spike_device[-1])
if separate:
generator_spike_device_bis.append(
nest.Create("spike_recorder", spike_generator))
nest.Connect(generator_spike_twin[i],
generator_spike_device_bis[-1])
else:
nest.Connect(generator_spike_twin[i],
generator_spike_device[-1])
if iaf > 0:
if (index_aif != -1
and i % nb_element == index_aif) or index_aif == -2:
neuron_test = nest.Create('iaf_psc_alpha', iaf)
generator_spike_neuron.append(nest.Create("spike_recorder", 1))
nest.Connect(generator_spike[i], neuron_test)
nest.Connect(neuron_test, generator_spike_neuron[-1])
if separate:
generator_spike_neuron_bis.append(
nest.Create("spike_recorder", 1))
nest.Connect(generator_spike_twin[i],
generator_spike_neuron_bis[-1])
else:
nest.Connect(generator_spike_twin[i],
generator_spike_neuron[-1])
# generator
generator_current_twin = []
generator_current_parrot = []
generator_current_parrot_bis = None
if separate:
generator_current_parrot_bis = []
generator_current_device = []
generator_current_device_bis = None
if separate:
generator_current_device_bis = []
generator_current_neuron = []
generator_current_neuron_bis = None
if separate:
generator_current_neuron_bis = []
for i in range(nb_mpi_generator_current):
data = np.concatenate(
generate_current(generator_current[i].tolist()[0], nb_run,
time_sim)[1])
generator_current_twin.append(
nest.Create("step_current_generator",
params={
'amplitude_times': data[:, 0],
'amplitude_values': data[:, 1],
}))
if parrot > 0:
if (index_parrot != -1
and i % nb_element == index_parrot) or index_parrot == -2:
new_neuron = nest.Create('iaf_cond_alpha', parrot)
generator_current_parrot.append(
nest.Create("multimeter",
params={
'record_from': ['V_m'],
"record_to": "memory"
}))
nest.Connect(generator_current[i], new_neuron)
nest.Connect(generator_current_parrot[-1], new_neuron)
if separate:
new_neuron_2 = nest.Create('iaf_cond_alpha', parrot)
generator_current_parrot_bis.append(
nest.Create("multimeter",
params={
'record_from': ['V_m'],
"record_to": "memory"
}))
nest.Connect(generator_current_twin[i], new_neuron_2)
nest.Connect(generator_current_parrot_bis[-1],
new_neuron_2)
else:
nest.Connect(generator_current_twin[i], new_neuron)
if spike_generator > 0:
if (index_device != -1
and i % nb_element == index_device) or index_device == -2:
neuron_test = nest.Create('iaf_cond_alpha', iaf)
generator_current_device.append(
nest.Create("multimeter",
params={
'record_from': ['V_m'],
"record_to": "memory"
}))
nest.Connect(generator_current[i], neuron_test)
nest.Connect(generator_current_device[-1], neuron_test)
if separate:
neuron_test_2 = nest.Create('iaf_cond_alpha', iaf)
generator_current_device_bis.append(
nest.Create("multimeter",
params={
'record_from': ['V_m'],
"record_to": "memory"
}))
nest.Connect(generator_current_device_bis[-1], neuron_test)
nest.Connect(generator_current_twin[i], neuron_test_2)
else:
nest.Connect(generator_current_twin[i], neuron_test)
if iaf > 0:
if (index_aif != -1
and i % nb_element == index_aif) or index_aif == -2:
neuron_test = nest.Create('iaf_psc_alpha', iaf)
generator_current_neuron.append(
nest.Create("multimeter",
params={
'record_from': ['V_m'],
"record_to": "memory"
}))
nest.Connect(generator_current[i], neuron_test)
nest.Connect(generator_current_neuron[-1], neuron_test)
if separate:
neuron_test_2 = nest.Create('iaf_psc_alpha', iaf)
generator_current_neuron_bis.append(
nest.Create("multimeter",
params={
'record_from': ['V_m'],
"record_to": "memory"
}))
nest.Connect(generator_current_neuron_bis[-1], neuron_test)
nest.Connect(generator_current_twin[i], neuron_test_2)
else:
nest.Connect(generator_current_twin[i], neuron_test)
# start simulation
nest.Prepare()
for i in range(nb_run):
nest.Run(time_sim)
nest.Cleanup()
# write result in file for the validation
devices_record_memory = [
('recorders_memory', recorders_twins),
('GS_parrot', generator_spike_parrot),
('GS_parrot_bis', generator_spike_parrot_bis),
('GS_spike_device', generator_spike_device),
('GS_spike_device_bis', generator_spike_device_bis),
('GS_spike_neuron', generator_spike_neuron),
('GS_spike_neuron_bis', generator_spike_neuron_bis),
('GC_parrot', generator_current_parrot),
('GC_parrot_bis', generator_current_parrot_bis),
('GC_device', generator_current_device),
('GC_device_bis', generator_current_device_bis),
('GC_neuron', generator_current_neuron),
('GC_neuron_bis', generator_current_neuron_bis)
]
for label, devices in devices_record_memory:
if devices is not None:
data_collect = []
for device in devices:
for data in nest.GetStatus(device):
data_collect.append(data['events'])
name_save = path + '/' + label + '_rank_' + str(
nest.Rank()) + '.npy'
np.save(name_save, data_collect, allow_pickle=True)
