def train(self, theta, theta_dot, tau1_ref, tau2_ref, learning_ratio,
momentum_learning_ratio, sim_time, filter_size):
nest.ResetNetwork()
self.simulate(sim_time, theta, theta_dot, filter_size)
tau1_error = self.tau1 - tau1_ref
tau2_error = self.tau2 - tau2_ref
self.lsm.train(tau1_error, tau2_error, learning_ratio,
momentum_learning_ratio, filter_size)
nest.ResetNetwork()
return
def reset():
nest.ResetNetwork()
nest.SetKernelStatus({'time': 0.0})
for p in populations:
for name, value in p.initial_values.items():
p.initialize(name, value)
state.running = False
def forward(self, input, timesteps=None):
# if timesteps not specified, set to default simulation time
if timesteps is None:
timesteps = self.simulation_time
# first reset the network
nest.ResetNetwork()
# set input generators to correct current
if self.add_bias_as_observation:
bias = torch.ones(1, dtype=torch.float)
input = torch.cat((input, bias), dim=0)
for i in range(0, len(self.inputs)):
nest.SetStatus([self.inputs[i]],
{"amplitude": input[i].detach().item()})
# simulate
nest.Simulate(timesteps)
# get recorded value from multimeter
outputs = []
for i in range(0, len(self.multimeters)):
dmm = nest.GetStatus(self.multimeters[i])[0]
Vms = dmm["events"]["V_m"]
outputs.append(Vms[-1])
# return a tensor of the outputs to be compatible with the other agents
return torch.tensor(outputs, dtype=torch.float)
def setUp(self):
nest.ResetKernel()
nest.SetKernelStatus({"total_num_virtual_procs": 4})
nest.ResetNetwork()
self.sim_time = 10000
self.sim_step = 100
nest.SetKernelStatus(
{'structural_plasticity_update_interval': self.sim_time + 1})
self.se_integrator = []
self.sim_steps = None
self.ca_nest = None
self.ca_python = None
self.se_nest = None
self.se_python = None
# build
self.pop = nest.Create('iaf_neuron', 10)
self.local_nodes = nest.GetNodes([0], {'model': 'iaf_neuron'}, True)[0]
self.spike_detector = nest.Create('spike_detector')
nest.Connect(self.pop, self.spike_detector, 'all_to_all')
noise = nest.Create('poisson_generator')
nest.SetStatus(noise, {"rate": 800000.0})
nest.Connect(noise, self.pop, 'all_to_all')
def reset(self):
nest.ResetNetwork()
nest.SetKernelStatus({'time': 0.0})
for p in self.populations:
for variable, initial_value in p.initial_values.items():
p._set_initial_value_array(variable, initial_value)
self.running = False
self.t_start = 0.0
self.segment_counter += 1
def simulate(self, Tsim, stimulus=None, reset=True):
if not stimulus is None:
self.pools['in_'].setSpikes(stimulus)
if reset:
nest.ResetNetwork()
print("Tsim(ms) = ", Tsim * 1000., " dt(ms) = ", self.dt * 1000.)
nest.Simulate(Tsim * 1000.)
print("Simulation complete")
def calculate_fitness(self):
nest.SetStatus(connections, params="weight", val=self.weights)
results = np.empty((8, 3))
for i in range(8):
nest.ResetNetwork()
nest.SetStatus(input, params="rate", val=[500.0 if j == i else 0.0 for j in range(8)])
nest.Simulate(100)
events = nest.GetStatus(recorder, keys="events")[0]["senders"] - np.min(output)
events = np.array([np.sum(events == j) for j in range(3)])
results[i] = events
maximum = np.max(results)
if maximum != 0.0:
results /= maximum
self._error = np.mean(np.sum((results - ideal) ** 2, axis=1))
self.res = results
def test_nework(rates, nodes_inp, simtime, Ntest=10):
# Test the current network in rate input patterns
# We go through all patterns in 'rates'. Each input pattern is presented Ntest times consecutively
# rates...........A list of input rate patterns. rates[i] is a vector of rates [Hz], one for each input neuron.
# rates[i][j] is the rate of the j-th input neuron in pattern i.
# nodes_inp[i]....GID of input neuron i
# simtime.........length of a single simulation run (one pattern presentation) in [s].
# Ntest...........Number of simulations per pattern
N_pat = len(rates)
nest.ResetNetwork()
for pattern in range(N_pat):
for ep in range(Ntest):
# set rates
#nest.ResetNetwork()
set_pattern(nodes_inp, rates, pattern)
# SIMULATE!! -----------------------------------------------------
nest.Simulate(simtime)
def simulate(self):
simtime = self.sim_params['simtime']
nest.ResetNetwork() # forget all previous simulation data
nest.SetKernelStatus({'time': 0.}) # turn back the clock
nest.Simulate(simtime) # simulate for a certain time period (ms)
# === GET DATA ===
spike_times = nest.GetStatus(self.spikedet, 'events')[0]['times']
spike_neurons = nest.GetStatus(self.spikedet, 'events')[0]['senders']
events = nest.GetStatus(self.multimet)[0]['events']
etimes = events['times']
# get the connections
# stdp_conns = nest.GetConnections(synapse_model="stdp_synapse")
# static_conns = nest.GetConnections(synapse_model="static_synapse")
return self.spikedet, self.multimet, spike_times, spike_neurons, events, etimes
def create_nest_objects(self):
# Number of NEST threads
NESTthr = 1
# Simulation parameters
sd_params = {'to_memory': True, 'withgid': True, 'withtime': True}
# Initialize seeds of random generators
if (self.poisson):
np.random.seed(int(time.time()))
seeds = np.arange(NESTthr) + int((time.time() * 100) % 2**32)
else:
seeds = np.arange(NESTthr)
# Initialize NEST kernel
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({
"local_num_threads": NESTthr,
"resolution": self.cells[0].dt,
"rng_seeds": list(seeds)
})
nest.set_verbosity('M_QUIET')
self.generators = []
self.spikedetector = 0
generator_params = {'rate': 10.}
# Create Poisson generators
for cell in self.cells:
generator = nest.Create('poisson_generator',
n=1,
params=generator_params)
self.generators.append(generator[0])
# Spike detector
self.spikedetector = nest.Create('spike_detector', params=sd_params)
nest.SetStatus(self.spikedetector, [{"n_events": 0}])
nest.Connect(self.generators, self.spikedetector)
def initialize(p):
# Function for initializing the NEST engine for simulation, including setting randomization seed
# Input: input parameters from YML files, path to experiment folder
nest.ResetKernel()
nest.ResetNetwork()
if not os.path.isdir(p["paths"]["temp_path"]):
os.makedirs(p["paths"]["temp_path"])
else:
iof.reset(p,reset=True)
if not os.path.isdir(p["paths"]["output_path"]):
os.makedirs(p["paths"]["output_path"])
nest.SetKernelStatus(p["simulation"]["nest_initialization"])
if p["simulation"]["nest_other"]["randomize"]:
msd = np.random.randint(100000,999999)
else:
msd = p["simulation"]["nest_other"]["rand_seed"]
N_vp = nest.GetKernelStatus(["total_num_virtual_procs"])[0]
pyrngs = [np.random.RandomState(s) for s in range(msd,msd+N_vp)]
nest.SetKernelStatus({"grng_seed":msd+N_vp, "rng_seeds":range(msd+N_vp+1,msd+2*N_vp+1)})
I_e = np.arange(0,500,10)
F ={ "GPTA" : [], "GPTI" : [], "STN" : [], "GPI" : [], "D1" : [], "D2": [], "FSN" : []}
for i_e in I_e:
NW = withSpike(nparam) # create the single neuron network with spike count
NW.setIe(i_e) # Set the desired I_e
NW.simulate() # Simulate the network
freq = NW.countSpikes()
nest.ResetNetwork()
for i in freq:
F[i] = F[i] + [freq[i]] # Put the count in a list for each neuron
with open('FI.dat', 'wb') as f: # Python 3: open(..., 'wb')
pickle.dump([I_e, F], f)
#plt.show()
def NESTSimulation(self, mosaic, load_mod=True):
if load_mod:
# Install modules just once
model = nest.Models(mtype='nodes', sel='parvo_neuron')
if not model:
nest.Install("parvo_neuron_module")
model = nest.Models(mtype='nodes', sel='AII_amacrine')
if not model:
nest.Install("AII_amacrine_module")
model = nest.Models(mtype='nodes', sel='ganglion_cell')
if not model:
nest.Install("ganglion_cell_module")
# Seeds
np.random.seed(int(time.time()))
self.seeds = np.arange(self.Params['NEST_threads']) + int(
(time.time() * 100) % 2**32)
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({
"local_num_threads": self.Params['NEST_threads'],
'resolution': self.Params['resolution'],
"rng_seeds": list(self.seeds)
})
# import network description
import retina
# get network info
models, layers, conns = retina.get_Network(self.Params)
# Create models
for m in models:
nest.CopyModel(m[0], m[1], m[2])
print("\n---Creating layers---\n")
# Create layers, store layer info in Python variable
layer_IDs = []
for l in layers:
exec("%s = tp.CreateLayer(%s)" % (l[0], l[1]), globals())
exec("copy_var = %s" % l[0], globals())
layer_IDs.append([l[0], copy_var, l[1]['elements']])
# print (l[0])
print("\n---Connecting layers---\n")
# Create connections, need to insert variable names
for c in conns:
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
# print ('tp.ConnectLayers(%s,%s)' % (c[0], c[1]))
# Initialize generators with the synaptic conductance values for ON and OFF
# bipolar cells according to the photoreceptor mosaic
cell = 0
for x in np.arange(self.Params['N']):
for y in np.arange(self.Params['N']):
# parameters of the sigmoid: ensure that glutamate release of the cone cell
# is about 1.0 in dark and approaches to 0.0 with inputs > 1000.0 trolands
if (mosaic[0, x, y] == 1):
self.L_cone_metabotropic[cell, :] = self.sigmoid_ON_Bip(
self.cone_response[0, cell, :], -50.0, 4.0)
else:
self.L_cone_metabotropic[cell, :] = np.zeros(
len(self.cone_response[0, cell, :]))
nest.SetStatus([
tp.GetElement(L_cones_metabotropic, (x, y))[0]
], [{
'amplitude_times': self.time,
'amplitude_values': list(self.L_cone_metabotropic[cell, :])
}])
if (mosaic[1, x, y] == 1):
self.M_cone_metabotropic[cell, :] = self.sigmoid_ON_Bip(
self.cone_response[1, cell, :], -50.0, 4.0)
else:
self.M_cone_metabotropic[cell, :] = np.zeros(
len(self.cone_response[1, cell, :]))
nest.SetStatus([
tp.GetElement(M_cones_metabotropic, (x, y))[0]
], [{
'amplitude_times': self.time,
'amplitude_values': list(self.M_cone_metabotropic[cell, :])
}])
if (mosaic[2, x, y] == 1):
self.S_cone_metabotropic[cell, :] = self.sigmoid_ON_Bip(
self.cone_response[2, cell, :], -50.0, 4.0)
else:
self.S_cone_metabotropic[cell, :] = np.zeros(
len(self.cone_response[2, cell, :]))
nest.SetStatus([
tp.GetElement(S_cones_metabotropic, (x, y))[0]
], [{
'amplitude_times': self.time,
'amplitude_values': list(self.S_cone_metabotropic[cell, :])
}])
if (mosaic[0, x, y] == 1):
self.L_cone_ionotropic[cell, :] = self.sigmoid_OFF_Bip(
self.cone_response[0, cell, :], -50.0, 4.0)
else:
self.L_cone_ionotropic[cell, :] = np.zeros(
len(self.cone_response[0, cell, :]))
nest.SetStatus(
[tp.GetElement(L_cones_ionotropic, (x, y))[0]],
[{
'amplitude_times': self.time,
'amplitude_values': list(
self.L_cone_ionotropic[cell, :])
}])
if (mosaic[1, x, y] == 1):
self.M_cone_ionotropic[cell, :] = self.sigmoid_OFF_Bip(
self.cone_response[1, cell, :], -50.0, 4.0)
else:
self.M_cone_ionotropic[cell, :] = np.zeros(
len(self.cone_response[1, cell, :]))
nest.SetStatus(
[tp.GetElement(M_cones_ionotropic, (x, y))[0]],
[{
'amplitude_times': self.time,
'amplitude_values': list(
self.M_cone_ionotropic[cell, :])
}])
if (mosaic[2, x, y] == 1):
self.S_cone_ionotropic[cell, :] = self.sigmoid_OFF_Bip(
self.cone_response[2, cell, :], -50.0, 4.0)
else:
self.S_cone_ionotropic[cell, :] = np.zeros(
len(self.cone_response[2, cell, :]))
nest.SetStatus(
[tp.GetElement(S_cones_ionotropic, (x, y))[0]],
[{
'amplitude_times': self.time,
'amplitude_values': list(
self.S_cone_ionotropic[cell, :])
}])
cell += 1
## Check-point: Visualization functions
# fig = tp.PlotLayer(H1_Horizontal_cells,nodesize =80)
# ctr = tp.FindCenterElement(H1_Horizontal_cells)
# tp.PlotTargets(ctr,Midget_bipolar_cells_L_ON,fig = fig,mask=conns[12][2]['mask'],
# kernel=conns[12][2]['kernel'],src_size=250,tgt_color='red',tgt_size=20,
# kernel_color='green')
# plt.show()
return layer_IDs
def reset(self):
nest.ResetNetwork()
def reset():
nest.ResetNetwork()
state.running = False
state.nominal_time = 0.0
def reset(self):
Simulation.reset(self)
nest.ResetNetwork()
def save_figs(controller,
string,
output_dir,
experiment_name,
suffix=".eps",
readout_and_output_only=True):
fn_head = output_dir + "/" + experiment_name
fn_foot = string + suffix
sim_time = 100.0
sim_n = 12
nest.ResetNetwork()
controller.simulate(sim_time, 0.0, 0.0)
controller.simulate(sim_time, 0.0, 0.0)
controller.simulate(sim_time, 0.25, 0.0)
controller.simulate(sim_time, 0.5, 0.0)
controller.simulate(sim_time, 0.0, 1.0)
controller.simulate(sim_time, 0.0, 2.0)
controller.simulate(sim_time, -0.5, 2.0)
controller.simulate(sim_time, -0.25, 0.0)
controller.simulate(sim_time, -0.5, 0.0)
controller.simulate(sim_time, 0.0, -1.0)
controller.simulate(sim_time, 0.0, -2.0)
controller.simulate(sim_time, 0.0, 0.0)
xticks_time = [sim_time * i for i in range(sim_n + 1)]
yticks_V_m = [-75.0 + 5.0 * i for i in range(6)]
controller.lsm.output_layer_tau1.plot_V_m(
0,
xticks=xticks_time,
yticks=yticks_V_m,
time_offset=-controller.total_sim_time + sim_time * sim_n,
file_name=fn_head + "_out_tau1_V_m_" + fn_foot)
controller.lsm.output_layer_tau2.plot_V_m(
0,
xticks=xticks_time,
yticks=yticks_V_m,
time_offset=-controller.total_sim_time + sim_time * sim_n,
file_name=fn_head + "_out_tau2_V_m_" + fn_foot)
controller.lsm.readout_layer_tau1.raster_plot(
xticks=xticks_time,
yticks=[1, len(controller.lsm.readout_layer_tau1.neurons)]
if len(controller.lsm.readout_layer_tau1.neurons) >= 2 else [],
ylabel="neuron ID"
if len(controller.lsm.readout_layer_tau1.neurons) >= 2 else "",
xticks_hist=xticks_time,
gid_offset=-controller.lsm.readout_layer_tau1.neurons[0],
time_offset=-controller.total_sim_time + sim_time * sim_n,
hist_binwidth=50.0,
file_name=fn_head + "_read_tau1_" + fn_foot)
controller.lsm.readout_layer_tau2.raster_plot(
xticks=xticks_time,
yticks=[1, len(controller.lsm.readout_layer_tau2.neurons)]
if len(controller.lsm.readout_layer_tau2.neurons) >= 2 else [],
ylabel="neuron ID"
if len(controller.lsm.readout_layer_tau2.neurons) >= 2 else "",
xticks_hist=xticks_time,
gid_offset=-controller.lsm.readout_layer_tau2.neurons[0],
time_offset=-controller.total_sim_time + sim_time * sim_n,
hist_binwidth=50.0,
file_name=fn_head + "_read_tau2_" + fn_foot)
if not readout_and_output_only:
spiked_neurons = set(
controller.lsm.liquid_neurons.get_detector_data(None, "senders"))
print len(spiked_neurons), "neurons in liquid spiked."
controller.lsm.liquid_neurons.raster_plot(
xticks=xticks_time,
yticks=[1, len(controller.lsm.liquid_neurons.neurons)]
if len(controller.lsm.liquid_neurons.neurons) >= 2 else [],
ylabel="neuron ID"
if len(controller.lsm.liquid_neurons.neurons) >= 2 else "",
xticks_hist=xticks_time,
gid_offset=-controller.lsm.liquid_neurons.neurons[0],
time_offset=-controller.total_sim_time + sim_time * sim_n,
hist_binwidth=50.0,
file_name=fn_head + "_liquid_" + fn_foot)
controller.lsm.input_layer_theta1.raster_plot(
xticks=xticks_time,
yticks=[1, len(controller.lsm.input_layer_theta1.neurons)]
if len(controller.lsm.input_layer_theta1.neurons) >= 2 else [],
ylabel="neuron ID"
if len(controller.lsm.input_layer_theta1.neurons) >= 2 else "",
xticks_hist=xticks_time,
gid_offset=-controller.lsm.input_layer_theta1.neurons[0],
time_offset=-controller.total_sim_time + sim_time * sim_n,
hist_binwidth=50.0,
file_name=fn_head + "_in_theta1_" + fn_foot)
controller.lsm.input_layer_theta2.raster_plot(
xticks=xticks_time,
yticks=[1, len(controller.lsm.input_layer_theta2.neurons)]
if len(controller.lsm.input_layer_theta2.neurons) >= 2 else [],
ylabel="neuron ID"
if len(controller.lsm.input_layer_theta2.neurons) >= 2 else "",
xticks_hist=xticks_time,
gid_offset=-controller.lsm.input_layer_theta2.neurons[0],
time_offset=-controller.total_sim_time + sim_time * sim_n,
hist_binwidth=50.0,
file_name=fn_head + "_in_theta2_" + fn_foot)
controller.lsm.input_layer_theta_dot1.raster_plot(
xticks=xticks_time,
yticks=[1, len(controller.lsm.input_layer_theta_dot1.neurons)]
if len(controller.lsm.input_layer_theta_dot1.neurons) >= 2 else [],
ylabel="neuron ID"
if len(controller.lsm.input_layer_theta_dot1.neurons) >= 2 else "",
xticks_hist=xticks_time,
gid_offset=-controller.lsm.input_layer_theta_dot1.neurons[0],
time_offset=-controller.total_sim_time + sim_time * sim_n,
hist_binwidth=50.0,
file_name=fn_head + "_in_theta_dot1_" + fn_foot)
controller.lsm.input_layer_theta_dot2.raster_plot(
xticks=xticks_time,
yticks=[1, len(controller.lsm.input_layer_theta_dot2.neurons)]
if len(controller.lsm.input_layer_theta_dot2.neurons) >= 2 else [],
ylabel="neuron ID"
if len(controller.lsm.input_layer_theta_dot2.neurons) >= 2 else "",
xticks_hist=xticks_time,
gid_offset=-controller.lsm.input_layer_theta_dot2.neurons[0],
time_offset=-controller.total_sim_time + sim_time * sim_n,
hist_binwidth=50.0,
file_name=fn_head + "_in_theta_dot2_" + fn_foot)
def simulation(Params):
#! =================
#! Import network
#! =================
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({"local_num_threads": Params['threads'],'resolution': Params['resolution']})
nest.SetStatus([0],{'print_time': True})
# initialize random seed
import time
msd = int(round(time.time() * 1000))
nest.SetKernelStatus({'grng_seed' : msd})
nest.SetKernelStatus({'rng_seeds' : range(msd+Params['threads']+1, msd+2*Params['threads']+1)})
import importlib
network = importlib.import_module(Params['network'])
reload(network)
models, layers, conns = network.get_Network(Params)
#import network_full_keiko
#reload(network_full_keiko)
# models, layers, conns = network_full_keiko.get_Network(Params)
# Create models
for m in models:
nest.CopyModel(m[0], m[1], m[2])
# Create layers, store layer info in Python variable
for l in layers:
exec '%s = tp.CreateLayer(l[1])' % l[0]
# Create connections, need to insert variable names
for c in conns:
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
# Prepare for file IO
import glob
# --- Set folder information
data_folder = Params['data_folder']
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
# --- To save spike data, set pairs of population id and its name
population_name = [ {'population': Retina_layer, 'name': 'Retina'},
{'population': Vp_vertical, 'name': 'Vp_v'},
{'population': Vp_horizontal, 'name': 'Vp_h'},
{'population': Rp_layer, 'name': 'Rp'},
{'population': Tp_layer, 'name': 'Tp'},
{'population': Vs_vertical, 'name': 'Vs_v'},
{'population': Vs_horizontal, 'name': 'Vs_h'}]
if Params.has_key('load_connections_from_file') and Params['load_connections_from_file']:
# Preparation
scramble_populations = [(Vp_vertical, 'Vp_vertical'),
(Vp_horizontal, 'Vp_horizontal')]
scramble_layers = ['L23_exc',
'L23_inh',
'L4_exc',
'L4_inh',
'L56_exc',
'L56_inh']
#scramble_layers = ['L4_exc']
# Get min &max index of each layer
h_min_idx = {}
h_max_idx = {}
v_min_idx = {}
v_max_idx = {}
target_neurons = []
for tmp_model in scramble_layers:
tmp_h = nest.GetLeaves(Vp_horizontal, properties={'model': tmp_model}, local_only=True)[0]
tmp_v = nest.GetLeaves(Vp_vertical, properties={'model': tmp_model}, local_only=True)[0]
h_min_idx[tmp_model] = min(tmp_h)
h_max_idx[tmp_model] = max(tmp_h)
v_min_idx[tmp_model] = min(tmp_v)
v_max_idx[tmp_model] = max(tmp_v)
target_neurons = target_neurons + range(h_min_idx[tmp_model], h_max_idx[tmp_model]+1) + range(v_min_idx[tmp_model], v_max_idx[tmp_model]+1)
# Save intact network information
for p in range(0, len(population_name), 1):
population = population_name[p]['population']
p_name = population_name[p]['name']
filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '_intact.dat'
filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '_intact.dat'
filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '_intact.dat'
filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '_intact.dat'
tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA)
tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA)
tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB)
# Reset network
nest.ResetNetwork()
'''
# The following code works, but takes time longer
# Get the list of connection_file
file_list = glob.glob(data_folder+'connection_*_intact.dat')
# Remove a file if the size is zero
remove_idx = []
for file_idx in range(0,len(file_list)):
intact_filename = file_list[file_idx]
fsize=os.path.getsize(intact_filename)
if fsize == 0:
remove_idx = remove_idx + [file_idx]
remove_idx.sort()
remove_idx.reverse()
for i in remove_idx:
del file_list[i]
'''
# TODO : put GABA_A, GABA_B and NMDA connection files
file_list = []
file_list.append({'filename': data_folder + 'connection_Vp_h_AMPA_syn_intact.dat',
'synapse': 'AMPA'})
file_list.append({'filename': data_folder + 'connection_Vp_v_AMPA_syn_intact.dat',
'synapse': 'AMPA'})
# Do the following procedure for all connection files
for file_idx in range(0,len(file_list)):
# Set filenames
intact_filename = file_list[file_idx]['filename']
receptors = nest.GetDefaults('ht_neuron')['receptor_types']
syn_model = receptors[ file_list[file_idx]['synapse'] ]
scrambled_filename = intact_filename.replace('intact', 'scrambled')
print(intact_filename)
# Get original(intact) connectivity data
src_network = np.loadtxt(open(intact_filename,'rb'))
np_pre = src_network[:, 0].astype(int)
np_post = src_network[:, 1].astype(int)
np_w = src_network[:, 2]
np_d = src_network[:, 3]
if Params['scrambled']:
# Preserve the original structure if
# -- pre neruons are not in target populations (i.e. scramble_layers)
# -- OR
# -- post neurons are not in target populations(i.e. scramble_layers)
preserved_rows = np.where( ~np.in1d(np_pre,target_neurons) | ~np.in1d(np_post,target_neurons) )[0]
preserved_pre = np_pre[preserved_rows]
preserved_post = np_post[preserved_rows]
preserved_w = np_w[preserved_rows]
preserved_d = np_d[preserved_rows]
# If len(preserved_rows)==len(np_pre), that means all neurons do not belong to scramble target areas.
# If len(preserved_rows) < len(np_pre), that means there are some neurons which need to be scrambled.
if len(preserved_rows) > len(np_pre):
print('ERROR: preserved_rows should not be larger than np_pre')
elif len(preserved_rows) == len(np_pre):
scrambled_pre = preserved_pre.tolist()
scrambled_post = preserved_post.tolist()
scrambled_w = preserved_w.tolist()
scrambled_d = preserved_d.tolist()
else: # --- len(preserved_rows) < len(np_pre)
scrambled_pre = []
scrambled_post = []
scrambled_w = []
scrambled_d = []
for tmp_model_pre in scramble_layers:
for tmp_model_post in scramble_layers:
# Get row index such that
# --- pre_neuron is in "tmp_model_pre"
# --- AND
# --- post_neuron is in "tmp_model_post"
bool_pre_h = np.in1d(np_pre, range(h_min_idx[tmp_model_pre], h_max_idx[tmp_model_pre]+1))
bool_pre_v = np.in1d(np_pre, range(v_min_idx[tmp_model_pre], v_max_idx[tmp_model_pre]+1))
bool_post_h = np.in1d(np_post, range(h_min_idx[tmp_model_post], h_max_idx[tmp_model_post]+1))
bool_post_v = np.in1d(np_post, range(v_min_idx[tmp_model_post], v_max_idx[tmp_model_post]+1))
tmp_rows_pre_h = np.where(bool_pre_h & (bool_post_h|bool_post_v))[0]
tmp_rows_pre_v = np.where(bool_pre_v & (bool_post_h|bool_post_v))[0]
# Get connectivity data such that pre neuron is in "tmp_model_pre"
# --- pre, w and d information should be kept.
# --- post index should be scrambled.
tmp_pre = np_pre[np.append(tmp_rows_pre_h, tmp_rows_pre_v)].tolist()
tmp_w = np_w[np.append(tmp_rows_pre_h, tmp_rows_pre_v)].tolist()
tmp_d = np_d[np.append(tmp_rows_pre_h, tmp_rows_pre_v)].tolist()
tmp_post = []
num_pre_h = len(tmp_rows_pre_h)
num_pre_v = len(tmp_rows_pre_v)
# --- pre : population = horizontal, model = "tmp_model_pre"
# --- post: population = horizontal(1/2)+vertical(1/2), model = "tmp_model_post"
if num_pre_h > 0:
# Assign the same number of connections for horizontal population and vertical population
num_scrambled_h = int(round(num_pre_h / 2))
num_scrambled_v = num_pre_h - num_scrambled_h
# Choose post neuron index randomly
scrambled_h_idx = rd.randint(low =h_min_idx[tmp_model_post],
high=h_max_idx[tmp_model_post],
size=[num_scrambled_h, 1])
scrambled_v_idx = rd.randint(low =v_min_idx[tmp_model_post],
high=v_max_idx[tmp_model_post],
size=[num_scrambled_v, 1])
# append scrambled post index
tmp_post = tmp_post + np.append(scrambled_h_idx, scrambled_v_idx).tolist()
# --- pre : population = vertical, model = "tmp_model_pre"
# --- post: population = horizontal(1/2)+vertical(1/2), model = "tmp_model_post"
if num_pre_v > 0:
# Assign the same number of connections for horizontal population and vertical population
num_scrambled_h = int(round(num_pre_v / 2))
num_scrambled_v = num_pre_v - num_scrambled_h
# Choose post neuron index randomly
scrambled_h_idx = rd.randint(low =h_min_idx[tmp_model_post],
high=h_max_idx[tmp_model_post],
size=[num_scrambled_h, 1])
scrambled_v_idx = rd.randint(low =v_min_idx[tmp_model_post],
high=v_max_idx[tmp_model_post],
size=[num_scrambled_v, 1])
# append scrambled post index
tmp_post = tmp_post + np.append(scrambled_h_idx, scrambled_v_idx).tolist()
scrambled_pre = scrambled_pre + tmp_pre
scrambled_post = scrambled_post + tmp_post
scrambled_w = scrambled_w + tmp_w
scrambled_d = scrambled_d +tmp_d
# append preserved connection data
scrambled_pre = scrambled_pre + preserved_pre.tolist()
scrambled_post = scrambled_post + preserved_post.tolist()
scrambled_w = scrambled_w + preserved_w.tolist()
scrambled_d = scrambled_d + preserved_d.tolist()
# Save scrambled_data
scrambled_all_data = np.zeros([len(scrambled_pre), 4])
scrambled_all_data[:, 0] = scrambled_pre
scrambled_all_data[:, 1] = scrambled_post
scrambled_all_data[:, 2] = scrambled_w
scrambled_all_data[:, 3] = scrambled_d
np.savetxt(scrambled_filename, scrambled_all_data, fmt='%.6f')
# Connect
con_dict = {'rule': 'one_to_one'}
syn_dict = {"model": "ht_synapse",
'receptor_type': syn_model,
'weight': scrambled_w,
'delay': scrambled_d,
}
nest.Connect(scrambled_pre, scrambled_post, con_dict, syn_dict)
else:
# just convert data type(ndarray->list) and connect based on the original data
pre = np_pre.tolist()
post = np_post.tolist()
w = np_w.tolist()
d = np_d.tolist()
# Connect
con_dict = {'rule': 'one_to_one'}
syn_dict = {"model": "ht_synapse",
'receptor_type': 1,
'weight': w,
'delay': d,
}
nest.Connect(pre, post, con_dict, syn_dict)
# nest.DisconnectOneToOne(tp_node, tgt_map[0], {"synapse_model": "AMPA_syn"})
#nest.Disconnect([tp_node], tgt_map, 'one_to_one', {"synapse_model": "AMPA_syn"})
# Get target nodes for the vertical population
# tp_nodes = nest.GetLeaves(Tp_layer, local_only=True)[0]
if Params.has_key('show_V4_num_conn_figure') and Params['show_V4_num_conn_figure']:
horizontal_nodes = nest.GetLeaves(Vp_horizontal, properties={'model': 'L4_exc'}, local_only=True)[0]
vertical_nodes = nest.GetLeaves(Vp_vertical, properties={'model': 'L4_exc'}, local_only=True)[0]
n_conns_hor = []
for (idx, horizontal_node) in enumerate(horizontal_nodes):
tgt_map = []
this_conns = nest.GetConnections([horizontal_node], horizontal_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_hor.append(len(tgt_map))
plt.figure()
plt.hist(n_conns_hor, range(0, max(n_conns_hor + [30])))
plt.title('# of connections Vp(h) L4pyr -> Vp(h) L4Pyr')
n_conns_hor = []
for (idx, horizontal_node) in enumerate(horizontal_nodes):
tgt_map = []
this_conns = nest.GetConnections([horizontal_node], vertical_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_hor.append(len(tgt_map))
# nest.DisconnectOneToOne(tp_node, tgt_map[0], {"synapse_model": "AMPA_syn"})
#nest.Disconnect([tp_node], tgt_map, 'one_to_one', {"synapse_model": "AMPA_syn"})
plt.figure()
plt.hist(n_conns_hor, range(0, max(n_conns_hor + [30])))
plt.title('# of connections Vp(h) L4pyr -> Vp(v) L4Pyr')
n_conns_ver = []
for (idx, vertical_node) in enumerate(vertical_nodes):
tgt_map = []
this_conns = nest.GetConnections([vertical_node], vertical_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_ver.append(len(tgt_map))
plt.figure()
plt.hist(n_conns_ver, range(0, max(n_conns_ver + [30])))
plt.title('# of connections Vp(v) L4pyr -> Vp(v) L4Pyr')
n_conns_ver = []
for (idx, vertical_node) in enumerate(vertical_nodes):
tgt_map = []
this_conns = nest.GetConnections([vertical_node], horizontal_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_ver.append(len(tgt_map))
plt.figure()
plt.hist(n_conns_ver, range(0, max(n_conns_ver + [30])))
plt.title('# of connections Vp(v) L4pyr -> Vp(h) L4Pyr')
plt.show()
# Check connections
# Connections from Retina to TpRelay
# tp.PlotTargets(tp.FindCenterElement(Retina_layer), Tp_layer)
if Params.has_key('show_V4_connectivity_figure') and Params['show_V4_connectivity_figure']:
Vp_hor_gids = tp.GetElement(Vp_horizontal, [0,0])
n_Vp_hor = len(Vp_hor_gids)
f = []
for idx in range(n_Vp_hor):
f.append(plt.figure())
positions = range(0,41,10)
positions[-1] -= 1
for xi in range(len(positions)):
for yi in range(len(positions)):
print("Position [%d,%d] : %d" %(xi,yi,yi*(len(positions))+xi+1))
x = positions[xi]
y = positions[yi]
Vp_hor_gids = tp.GetElement(Vp_horizontal, [x,y])
Vp_hor_status = nest.GetStatus(Vp_hor_gids)
for (idx, n) in enumerate(Vp_hor_status):
if n['Tau_theta'] == 2.0:
print idx
try:
f[idx].add_subplot(len(positions), len(positions), yi*(len(positions))+xi+1)
tp.PlotTargets([Vp_hor_gids[idx]], Vp_horizontal, 'L4_exc', 'AMPA_syn', f[idx])
except:
print('%i bad' % Vp_hor_gids[idx])
plt.show()
# Connections from TpRelay to L4pyr in Vp (horizontally tuned)
#topo.PlotTargets(topo.FindCenterElement(Tp), Vp_h, 'L4pyr', 'AMPA')
#pylab.title('Connections TpRelay -> Vp(h) L4pyr')
#pylab.show()
# Connections from TpRelay to L4pyr in Vp (vertically tuned)
#topo.PlotTargets(topo.FindCenterElement(Tp), Vp_v, 'L4pyr', 'AMPA')
#pylab.title('Connections TpRelay -> Vp(v) L4pyr')
#pylab.show()
'''
# pablo
# Create vertical grating
for n in nest.GetLeaves(Retina_layer)[0]:
retina_0 = (nest.GetLeaves(Retina_layer)[0])[0]
col = (n-retina_0)/Params['Np']
cells_per_degree = Params['Np']/Params['visSize']
cells_per_cycle = cells_per_degree/Params['spatial_frequency']
nest.SetStatus([n], { "phase": col * 360/(cells_per_cycle-1) })
'''
### keiko
if Params['lambda_dg'] >= 0:
[nest.SetStatus([n], {"phase": phaseInit(tp.GetPosition([n])[0],
Params["lambda_dg"],
Params["phi_dg"])})
for n in nest.GetLeaves(Retina_layer)[0]]
else:
# Leonardo: Random retina input
[nest.SetStatus([n], {"phase": phaseInit(tp.GetPosition([n])[0],
np.pi * np.random.rand(),
np.pi * np.random.rand())})
for n in nest.GetLeaves(Retina_layer)[0]]
# --------------------------------------------------------------------#
# ---------- SET IB NEURONS ----------------------------------------- #
# --------------------------------------------------------------------#
# 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron.
# That is achieved by setting pacemaker current I_h.
# So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0.
# (Other cortical neuron do not have I_h, thus h_g_peak=0.0)
L56_vertical_idx = [nd for nd in nest.GetLeaves(Vp_vertical)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
L56_horizontal_idx = [nd for nd in nest.GetLeaves(Vp_horizontal)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
num_neuron = len(L56_vertical_idx)
num_ib = int(num_neuron*0.3)
ridx_vertical = np.random.randint(num_neuron, size=(1,num_ib))[0]
ridx_horizontal = np.random.randint(num_neuron, size=(1,num_ib))[0]
for i in range(1,num_ib,1):
nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'h_g_peak': 1.0})
nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]], {'h_g_peak': 1.0})
# initiate network activity
#nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(500.0)
#! =================
#! Recording devices
#! =================
nest.CopyModel('multimeter', 'RecordingNode',
params = {'interval' : Params['resolution'],
#'record_from': ['V_m'],
'record_from': ['V_m',
'I_syn_AMPA',
'I_syn_NMDA',
'I_syn_GABA_A',
'I_syn_GABA_B',
'g_AMPA',
'g_NMDA',
'g_GABAA',
'g_GABAB',
'I_NaP',
'I_KNa',
'I_T',
'I_h'],
'record_to' : ['memory'],
'withgid' : True,
'withtime' : True})
recorders = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh')]:
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L56_exc'),
(Rp_layer, 'Rp')]:
rec = nest.Create('RecordingNode')
recorders.append([rec,population,model])
if (model=='Retina'):
nest.SetStatus(rec,{'record_from': ['rate']})
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
nest.Connect(rec, tgts)
#! =================
#! Spike detector
#! =================
detectors = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh')]:
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc')]:
rec = nest.Create('spike_detector', params={"withgid": True, "withtime": True})
#rec = nest.Create('spike_detector')
detectors.append([rec,population,model])
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
if model == 'Retina':
for t in tgts:
try:
nest.Connect([t], rec)
print('connected %d' % t)
except:
print('%d did not work' % t)
else:
nest.Connect(tgts, rec)
#! ====================
#! Simulation
#! ====================
'''
# change gKL to 0.8 in all populations (necessary to get a little stronger evoked response)
for l in layers:
sim_elements = l[1]['elements']
for m in np.arange(0,np.size(sim_elements),1):
if(np.size(sim_elements)==1):
sim_model = sim_elements
else:
sim_model = sim_elements[m]
exec("la = %s" % l[0])
pop = [nd for nd in nest.GetLeaves(la)[0] if nest.GetStatus([nd], 'model')[0]==sim_model]
if (l[0]!='Retina_layer'):
for cell in pop:
nest.SetStatus([cell], {'g_KL':0.8})
'''
# Simulate
for t in Params['intervals']:
#if (t == 250.0): # Stimulus ON
# # if (t == 1500.0): # Stimulus ON
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 45.0})
#else: # Stimulus OFF
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
if Params['input_flag']==True:
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': Params['ret_rate']})
else:
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(t)
'''
data_folder = Params['data_folder']
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
'''
#! ====================
#! Plot Results
#! ====================
if Params.has_key('show_main_figure') and Params['show_main_figure']:
print "plotting..."
rows = 9
cols = 2
fig = plt.figure(num=None, figsize=(13, 24), dpi=100)
fig.subplots_adjust(hspace=0.4)
# Plot A: membrane potential rasters
recorded_models = [(Retina_layer,'Retina'),
(Vp_vertical,'L23_exc'),
(Vp_vertical,'L4_exc'),
(Vp_vertical,'L56_exc'),
(Rp_layer,'Rp'),
(Tp_layer,'Tp_exc')]
#plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
#starting_neuron = 800+1
#plotting.potential_raster(fig,recorders,recorded_models,starting_neuron,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plt.title('Evoked')
# Plot B: individual intracellular traces
recorded_models =[(Vp_vertical,'L4_exc'),
(Vp_vertical,'L4_inh')]
#plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6) #original
# keiko
total_time = 0.0
for t in Params['intervals']:
total_time += t
#draw_neuron = (Params['Np']*Params['Np']/2)
#plotting.intracellular_potentials(fig, recorders, recorded_models, draw_neuron, rows, cols, 6, total_time)
plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6, total_time)
#plotting.intracellular_potentials(fig, recorders, recorded_models, 820, rows, cols, 6, total_time)
# Plot C: topographical activity of the vertical and horizontal layers
if Params.has_key('start_membrane_potential') and Params.has_key('end_membrane_potential'):
start = Params['start_membrane_potential']
stop = Params['end_membrane_potential']
else:
start = 130.0
stop = 140.0
recorded_models = [(Vp_vertical,'L23_exc')]
labels = ["Vertical"]
plotting.topographic_representation(fig,
recorders,
recorded_models,
labels,
Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
rows,
cols,
start,
stop,
8,
0)
recorded_models = [(Vp_horizontal,'L23_exc')]
labels = ["Horizontal"]
plotting.topographic_representation(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,start,stop,8,1)
fig.savefig(data_folder + 'figure3.png', dpi=100)
plt.show()
# Plot D: movie
#labels = ["Evoked_Vp_L23_Vertical","Evoked_Vp_L23_Horizontal"]
#recorded_models = [(Vp_vertical,'L23_exc'),(Vp_horizontal,'L23_exc')]
#plotting.makeMovie(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'])
#! ====================
#! Save Results
#! ====================
print('save recorders data')
for rec, population, model in recorders:
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
data = nest.GetStatus(rec)[0]['events']
if model == 'Retina':
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'rate': data['rate']})
else:
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'V_m': data['V_m'],
'I_syn_AMPA': data['I_syn_AMPA'],
'I_syn_NMDA': data['I_syn_NMDA'],
'I_syn_GABA_A': data['I_syn_GABA_A'],
'I_syn_GABA_B': data['I_syn_GABA_B'],
'g_AMPA': data['g_AMPA'],
'g_NMDA': data['g_NMDA'],
'g_GABAA': data['g_GABAA'],
'g_GABAB': data['g_GABAB']} )
print('save raster images')
plt.close()
for rec, population, model in detectors:
spikes = nest.GetStatus(rec, 'events')[0]
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
if len(nest.GetStatus(rec)[0]['events']['senders']) > 3:
raster = raster_plot.from_device(rec, hist=True)
pylab.title( p_name + '_' + model )
f = raster[0].figure
f.set_size_inches(15, 9)
f.savefig(data_folder + 'spikes_' + p_name + '_' + model + '.png', dpi=100)
plt.close()
# Set filename and save spike data
filename = data_folder + 'spike_' + p_name + '_' + model + '.pickle'
pickle.dump(spikes, open(filename, 'w'))
scipy.io.savemat(data_folder + '/spike_' + p_name + '_' + model + '.mat', mdict={'senders': spikes['senders'], 'times': spikes['times']})
#filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat'
#tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
'''
filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat'
filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '.dat'
filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '.dat'
filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '.dat'
tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA)
tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA)
tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB)
'''
'''
for p in range(0, len(population_name), 1):
population = population_name[p]['population']
p_name = population_name[p]['name']
filename_nodes = data_folder + '/gid_' + p_name + '.dat'
tp.DumpLayerNodes(population, filename_nodes)
'''
network_script = Params['network'] + '.py'
shutil.copy2(network_script, Params['data_folder'] + network_script)
print('end')
def Simulate(self,
simtime,
state,
readtimeout,
plast_params,
train=True,
epsilon=True):
#Reset the spike detectors
start_time = time.time()
nest.ResetNetwork()
nest.Simulate(simtime)
#print("--- %s seconds for network ---" % (time.time() - start_time))
#Returns the action Neuron ID. ACtion % nActions yields the
#chosen action 0 based -> 0, 1, 2, 3
start_time = time.time()
action = self.ReadOut(simtime, readtimeout)
#Epsilon schedule overtaken from QLearning library
#mdptoolbox.mdp.QLearning
#Check if a random step should be taken
if epsilon:
rnd = np.random.rand()
if rnd > (1 -
(1 / math.log(self.currentIteration + 2))): #self.eps:
action = np.random.randint(0, self.nActions)
#Add the action/state to the lists
self.states.append(state)
self.actions.append(action)
#State is also represented as the state neuron ID
nextState, reward = self.PerformAction(action, state)
self.rewards.append(reward)
#Skip the q-table update in the first iteration
if train:
if self.currentIteration > 0:
#Update synapses before the reward
if self.lam:
self.update_weights_tdlam(plast_params)
else:
self.update_weights_td1(plast_params)
self.currentIteration += 1
if (self.currentIteration % self.evaluationIter) == 0:
self.CompareQ()
#Check for cycle or final state
cycle = self.DetectCycle()
if cycle:
#print("--- %s seconds for the rest---" % (time.time() - start_time))
return np.random.randint(0, self.nStates), reward
else:
#print("--- %s seconds for the rest---" % (time.time() - start_time))
return nextState, reward
else:
#print("--- %s seconds for the rest---" % (time.time() - start_time))
return nextState, reward
#print("--- %s seconds for the rest---" % (time.time() - start_time))
return nextState, reward
def simulation(Params):
#! =================
#! Import network
#! =================
import importlib
import time
#network_names = ['network_full_keiko', 'network_full_leonardo']
network_names = ['network_full_keiko', 'network_full_keiko']
colors = [[0, 0, 1, .5], [0, 1, 0, .5]]
fig, axs = plt.subplots(2, 2)
for (inet, netname) in enumerate(network_names):
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({
"local_num_threads": Params['threads'],
'resolution': Params['resolution']
})
nest.SetStatus([0], {'print_time': True})
# initialize random seed
msd = int(round(time.time() * 1000))
nest.SetKernelStatus({'grng_seed': msd})
nest.SetKernelStatus({
'rng_seeds':
range(msd + Params['threads'] + 1, msd + 2 * Params['threads'] + 1)
})
network = importlib.import_module(netname)
reload(network)
models, layers, conns = network.get_Network(Params)
# import network_full_keiko
# reload(network_full_keiko)
# models, layers, conns = network_full_keiko.get_Network(Params)
# Create models
for m in models:
nest.CopyModel(m[0], m[1], m[2])
# Create layers, store layer info in Python variable
for l in layers:
exec '%s = tp.CreateLayer(l[1])' % l[0]
# Create connections, need to insert variable names
for c in conns:
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
if Params.has_key('show_V4_num_conn_figure'
) and Params['show_V4_num_conn_figure']:
horizontal_nodes = nest.GetLeaves(Vp_horizontal,
properties={'model': 'L4_exc'},
local_only=True)[0]
vertical_nodes = nest.GetLeaves(Vp_vertical,
properties={'model': 'L4_exc'},
local_only=True)[0]
print('Ploting #1')
n_conns_hor = []
for (idx, horizontal_node) in enumerate(horizontal_nodes):
tgt_map = []
this_conns = nest.GetConnections([horizontal_node],
horizontal_nodes,
synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_hor.append(len(tgt_map))
plt.axes(axs[0, 0])
plt.hist(n_conns_hor,
range(0, max(n_conns_hor + [30])),
fc=colors[inet])
plt.title('# of connections Vp(h) L4pyr -> Vp(h) L4Pyr')
print('Ploting #2')
n_conns_hor = []
for (idx, horizontal_node) in enumerate(horizontal_nodes):
tgt_map = []
this_conns = nest.GetConnections([horizontal_node],
vertical_nodes,
synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_hor.append(len(tgt_map))
# nest.DisconnectOneToOne(tp_node, tgt_map[0], {"synapse_model": "AMPA_syn"})
#nest.Disconnect([tp_node], tgt_map, 'one_to_one', {"synapse_model": "AMPA_syn"})
plt.axes(axs[0, 1])
plt.hist(n_conns_hor,
range(0, max(n_conns_hor + [30])),
fc=colors[inet])
plt.title('# of connections Vp(h) L4pyr -> Vp(v) L4Pyr')
print('Ploting #3')
n_conns_ver = []
for (idx, vertical_node) in enumerate(vertical_nodes):
tgt_map = []
this_conns = nest.GetConnections([vertical_node],
vertical_nodes,
synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_ver.append(len(tgt_map))
plt.axes(axs[1, 1])
plt.hist(n_conns_ver,
range(0, max(n_conns_ver + [30])),
fc=colors[inet])
plt.title('# of connections Vp(v) L4pyr -> Vp(v) L4Pyr')
print('Ploting #4')
n_conns_ver = []
for (idx, vertical_node) in enumerate(vertical_nodes):
tgt_map = []
this_conns = nest.GetConnections([vertical_node],
horizontal_nodes,
synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_ver.append(len(tgt_map))
plt.axes(axs[1, 0])
plt.hist(n_conns_ver,
range(0, max(n_conns_ver + [30])),
fc=colors[inet])
plt.title('# of connections Vp(v) L4pyr -> Vp(h) L4Pyr')
plt.show()
# Check connections
# Connections from Retina to TpRelay
# tp.PlotTargets(tp.FindCenterElement(Retina_layer), Tp_layer)
if Params.has_key('show_V4_connectivity_figure'
) and Params['show_V4_connectivity_figure']:
Vp_hor_gids = tp.GetElement(Vp_horizontal, [0, 0])
n_Vp_hor = len(Vp_hor_gids)
f = []
for idx in range(n_Vp_hor):
f.append(plt.figure())
positions = range(0, 41, 10)
positions[-1] -= 1
for xi in range(len(positions)):
for yi in range(len(positions)):
print("Position [%d,%d] : %d" % (xi, yi, yi *
(len(positions)) + xi + 1))
x = positions[xi]
y = positions[yi]
Vp_hor_gids = tp.GetElement(Vp_horizontal, [x, y])
Vp_hor_status = nest.GetStatus(Vp_hor_gids)
for (idx, n) in enumerate(Vp_hor_status):
if n['Tau_theta'] == 2.0:
print idx
try:
f[idx].add_subplot(len(positions), len(positions),
yi * (len(positions)) + xi + 1)
tp.PlotTargets([Vp_hor_gids[idx]], Vp_horizontal,
'L4_exc', 'AMPA_syn', f[idx])
except:
print('%i bad' % Vp_hor_gids[idx])
plt.show()
# Connections from TpRelay to L4pyr in Vp (horizontally tuned)
#topo.PlotTargets(topo.FindCenterElement(Tp), Vp_h, 'L4pyr', 'AMPA')
#pylab.title('Connections TpRelay -> Vp(h) L4pyr')
#pylab.show()
# Connections from TpRelay to L4pyr in Vp (vertically tuned)
#topo.PlotTargets(topo.FindCenterElement(Tp), Vp_v, 'L4pyr', 'AMPA')
#pylab.title('Connections TpRelay -> Vp(v) L4pyr')
#pylab.show()
'''
# pablo
# Create vertical grating
for n in nest.GetLeaves(Retina_layer)[0]:
retina_0 = (nest.GetLeaves(Retina_layer)[0])[0]
col = (n-retina_0)/Params['Np']
cells_per_degree = Params['Np']/Params['visSize']
cells_per_cycle = cells_per_degree/Params['spatial_frequency']
nest.SetStatus([n], { "phase": col * 360/(cells_per_cycle-1) })
'''
### keiko
if Params['lambda_dg'] >= 0:
[
nest.SetStatus(
[n], {
"phase":
phaseInit(
tp.GetPosition([n])[0], Params["lambda_dg"],
Params["phi_dg"])
}) for n in nest.GetLeaves(Retina_layer)[0]
]
else:
# Leonardo: Random retina input
[
nest.SetStatus(
[n], {
"phase":
phaseInit(
tp.GetPosition([n])[0], np.pi * np.random.rand(),
np.pi * np.random.rand())
}) for n in nest.GetLeaves(Retina_layer)[0]
]
# --------------------------------------------------------------------#
# ---------- SET IB NEURONS ----------------------------------------- #
# --------------------------------------------------------------------#
# 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron.
# That is achieved by setting pacemaker current I_h.
# So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0.
# (Other cortical neuron do not have I_h, thus h_g_peak=0.0)
L56_vertical_idx = [
nd for nd in nest.GetLeaves(Vp_vertical)[0]
if nest.GetStatus([nd], 'model')[0] == 'L56_exc'
]
L56_horizontal_idx = [
nd for nd in nest.GetLeaves(Vp_horizontal)[0]
if nest.GetStatus([nd], 'model')[0] == 'L56_exc'
]
num_neuron = len(L56_vertical_idx)
num_ib = int(num_neuron * 0.3)
ridx_vertical = np.random.randint(num_neuron, size=(1, num_ib))[0]
ridx_horizontal = np.random.randint(num_neuron, size=(1, num_ib))[0]
for i in range(1, num_ib, 1):
nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'h_g_peak': 1.0})
nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]],
{'h_g_peak': 1.0})
# initiate network activity
#nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(
nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(500.0)
#! =================
#! Recording devices
#! =================
nest.CopyModel(
'multimeter',
'RecordingNode',
params={
'interval':
Params['resolution'],
#'record_from': ['V_m'],
'record_from': [
'V_m', 'I_syn_AMPA', 'I_syn_NMDA', 'I_syn_GABA_A',
'I_syn_GABA_B', 'g_AMPA', 'g_NMDA', 'g_GABAA', 'g_GABAB',
'I_NaP', 'I_KNa', 'I_T', 'I_h'
],
'record_to': ['memory'],
'withgid':
True,
'withtime':
True
})
recorders = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh')]:
'''
for population, model in [(Retina_layer, 'Retina'), (Tp_layer, 'Tp_exc'),
(Tp_layer, 'Tp_inh'), (Vp_vertical, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L56_exc'), (Rp_layer, 'Rp')]:
rec = nest.Create('RecordingNode')
recorders.append([rec, population, model])
if (model == 'Retina'):
nest.SetStatus(rec, {'record_from': ['rate']})
tgts = [
nd for nd in nest.GetLeaves(population)[0]
if nest.GetStatus([nd], 'model')[0] == model
]
nest.Connect(rec, tgts)
#! =================
#! Spike detector
#! =================
detectors = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh')]:
'''
for population, model in [(Retina_layer, 'Retina'), (Tp_layer, 'Tp_exc'),
(Tp_layer, 'Tp_inh'), (Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc')]:
rec = nest.Create('spike_detector',
params={
"withgid": True,
"withtime": True
})
#rec = nest.Create('spike_detector')
detectors.append([rec, population, model])
tgts = [
nd for nd in nest.GetLeaves(population)[0]
if nest.GetStatus([nd], 'model')[0] == model
]
if model == 'Retina':
for t in tgts:
try:
nest.Connect([t], rec)
print('connected %d' % t)
except:
print('%d did not work' % t)
else:
nest.Connect(tgts, rec)
#! ====================
#! Simulation
#! ====================
'''
# change gKL to 0.8 in all populations (necessary to get a little stronger evoked response)
for l in layers:
sim_elements = l[1]['elements']
for m in np.arange(0,np.size(sim_elements),1):
if(np.size(sim_elements)==1):
sim_model = sim_elements
else:
sim_model = sim_elements[m]
exec("la = %s" % l[0])
pop = [nd for nd in nest.GetLeaves(la)[0] if nest.GetStatus([nd], 'model')[0]==sim_model]
if (l[0]!='Retina_layer'):
for cell in pop:
nest.SetStatus([cell], {'g_KL':0.8})
'''
# Simulate
for t in Params['intervals']:
#if (t == 250.0): # Stimulus ON
# # if (t == 1500.0): # Stimulus ON
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 45.0})
#else: # Stimulus OFF
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
if Params['input_flag'] == True:
nest.SetStatus(
nest.GetLeaves(Retina_layer)[0],
{'amplitude': Params['ret_rate']})
else:
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(t)
#! ====================
#! Plot Results
#! ====================
if Params.has_key('show_main_figure') and Params['show_main_figure']:
print "plotting..."
rows = 9
cols = 2
fig = plt.figure()
fig.subplots_adjust(hspace=0.4)
# Plot A: membrane potential rasters
recorded_models = [(Retina_layer, 'Retina'), (Vp_vertical, 'L23_exc'),
(Vp_vertical, 'L4_exc'), (Vp_vertical, 'L56_exc'),
(Rp_layer, 'Rp'), (Tp_layer, 'Tp_exc')]
#plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plotting.potential_raster(fig, recorders, recorded_models, 0,
Params['Np'], np.sum(Params['intervals']),
Params['resolution'], rows, cols, 0)
#starting_neuron = 800+1
#plotting.potential_raster(fig,recorders,recorded_models,starting_neuron,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plt.title('Evoked')
# Plot B: individual intracellular traces
recorded_models = [(Vp_vertical, 'L4_exc'), (Vp_vertical, 'L4_inh')]
#plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6) #original
# keiko
total_time = 0.0
for t in Params['intervals']:
total_time += t
#draw_neuron = (Params['Np']*Params['Np']/2)
#plotting.intracellular_potentials(fig, recorders, recorded_models, draw_neuron, rows, cols, 6, total_time)
plotting.intracellular_potentials(fig, recorders, recorded_models, 21,
rows, cols, 6, total_time)
#plotting.intracellular_potentials(fig, recorders, recorded_models, 820, rows, cols, 6, total_time)
# Plot C: topographical activity of the vertical and horizontal layers
recorded_models = [(Vp_vertical, 'L23_exc')]
labels = ["Vertical"]
start = 130.0
stop = 140.0
#start = 650.0
#stop = 660.0
plotting.topographic_representation(fig, recorders, recorded_models,
labels, Params['Np'],
np.sum(Params['intervals']),
Params['resolution'], rows, cols,
start, stop, 8, 0)
recorded_models = [(Vp_horizontal, 'L23_exc')]
labels = ["Horizontal"]
start = 130.0
stop = 140.0
#start = 650.0
#stop = 660.0
plotting.topographic_representation(fig, recorders, recorded_models,
labels, Params['Np'],
np.sum(Params['intervals']),
Params['resolution'], rows, cols,
start, stop, 8, 1)
plt.show()
# Plot D: movie
#labels = ["Evoked_Vp_L23_Vertical","Evoked_Vp_L23_Horizontal"]
#recorded_models = [(Vp_vertical,'L23_exc'),(Vp_horizontal,'L23_exc')]
#plotting.makeMovie(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'])
#! ====================
#! Save Results
#! ====================
print('save recorders data')
# Set folder
#rootdir = '/home/kfujii2/newNEST2/ht_model_pablo_based/data/'
#expdir = 'random/'
# expdir = 'random_full/'
# expdir = 'structured_full/'
# data_folder = rootdir + expdir
data_folder = Params['data_folder']
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
# To save spike data, set pairs of population id and its name
population_name = [{
'population': Retina_layer,
'name': 'Retina'
}, {
'population': Vp_vertical,
'name': 'Vp_v'
}, {
'population': Vp_horizontal,
'name': 'Vp_h'
}, {
'population': Rp_layer,
'name': 'Rp'
}, {
'population': Tp_layer,
'name': 'Tp'
}, {
'population': Vs_vertical,
'name': 'Vs_v'
}, {
'population': Vs_horizontal,
'name': 'Vs_h'
}]
for rec, population, model in recorders:
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
data = nest.GetStatus(rec)[0]['events']
if model == 'Retina':
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' +
model + '.mat',
mdict={
'senders': data['senders'],
'rate': data['rate']
})
else:
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' +
model + '.mat',
mdict={
'senders': data['senders'],
'V_m': data['V_m'],
'I_syn_AMPA': data['I_syn_AMPA'],
'I_syn_NMDA': data['I_syn_NMDA'],
'I_syn_GABA_A': data['I_syn_GABA_A'],
'I_syn_GABA_B': data['I_syn_GABA_B'],
'g_AMPA': data['g_AMPA'],
'g_NMDA': data['g_NMDA'],
'g_GABAA': data['g_GABAA'],
'g_GABAB': data['g_GABAB']
})
print('save raster images')
plt.close()
for rec, population, model in detectors:
spikes = nest.GetStatus(rec, 'events')[0]
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
if len(nest.GetStatus(rec)[0]['events']['senders']) > 3:
raster = raster_plot.from_device(rec, hist=True)
pylab.title(p_name + '_' + model)
f = raster[0].figure
f.set_size_inches(15, 9)
f.savefig(data_folder + 'spikes_' + p_name + '_' + model + '.png',
dpi=100)
plt.close()
# Set filename and save spike data
filename = data_folder + 'spike_' + p_name + '_' + model + '.pickle'
pickle.dump(spikes, open(filename, 'w'))
scipy.io.savemat(data_folder + '/spike_' + p_name + '_' + model +
'.mat',
mdict={
'senders': spikes['senders'],
'times': spikes['times']
})
'''
filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat'
filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '.dat'
filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '.dat'
filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '.dat'
tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA)
tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA)
tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB)
'''
'''
for p in range(0, len(population_name), 1):
population = population_name[p]['population']
p_name = population_name[p]['name']
filename_nodes = data_folder + '/gid_' + p_name + '.dat'
tp.DumpLayerNodes(population, filename_nodes)
'''
network_script = Params['network'] + '.py'
shutil.copy2(network_script, Params['data_folder'] + network_script)
print('end')
def main(args, rt, sim_num, var_id):
###########################################
#### PARAMETERS #######################
###########################################
freq_num = args['freq_num'] # number of auditory frequencies
amp_factor = args[
'amp_factor'] # strength of signal coming from generators
sim_time = args['sim_time'] # duration of simulation (ms)
grid_size = args['grid_size'] # side lengths of topological layers (nm)
base_stim_rate = args['base_stim_rate'] # stimulus rate (Hz)
tun_rad = args['tun_rad'] # broadness of tuning curve
neuron_mod = args['neuron_mod']
stim_layer_param = {
'extent': grid_size, # size of layer (nm^2)
'rows': amp_factor, # strength of signal amplification
'columns': freq_num, # one column per frequency
'elements': 'poisson_generator'
}
pyr_layer_param = {
'extent': grid_size, # size of layer (nm^2)
'rows': args['pyr_layer_num'], # neurons per frequency
'columns': freq_num, # one column per frequency
'elements': neuron_mod
}
inh_layer_param = {
'extent': grid_size, # size of layer (nm^2)
'rows': args['inh_layer_num'], # neurons per frequency
'columns': freq_num, # one column per frequency
'elements': neuron_mod
}
stim_conn_param = {
'connection_type': 'divergent', # connection based on target layer
'mask': {
'circular': {
'radius': grid_size[0] * args['stim_conn_rad']
}
},
'kernel': {
'gaussian': { # connection probability based on distance
'p_center': args['stim_conn_p_center'],
'sigma': args['stim_conn_p_sigma']
}
},
'weights': {
'gaussian': { # weight of connection based on distance
'p_center': args['stim_conn_weight_center'],
'sigma': args['stim_conn_weight_sigma'],
'min': 0.0
}
}
}
pyr_conn_param = {
'connection_type': 'divergent', # connection based on target layer
'mask': {
'circular': {
'radius': grid_size[0] * args['pyr_conn_rad']
}
},
'kernel': {
'gaussian': { # connection probability based on distance
'p_center': args['pyr_conn_p_center'],
'sigma': args['pyr_conn_p_sigma']
}
},
'weights': {
'gaussian': { # weight of connection based on distance
'p_center': args['pyr_conn_weight_center'],
'sigma': args['pyr_conn_weight_sigma'],
'min': 0.0
}
}
}
inh_conn_param = {
'connection_type': 'divergent', # connection based on target layer
'mask': {
'circular': {
'radius': grid_size[0] * args['inh_conn_rad']
}
},
'kernel': {
'gaussian': { # connection probability based on distance
'p_center': args['inh_conn_p_center'],
'sigma': args['inh_conn_p_sigma']
}
},
'weights': {
'gaussian': { # weight of connection based on distance
'p_center': -1 * args['inh_conn_weight_center'],
'sigma': args['inh_conn_weight_sigma'],
'max': 0.0
}
}
}
pypy_conn_param = {
'connection_type': 'divergent', # connection based on target layer
'mask': {
'circular': {
'radius': grid_size[0] * args['pypy_conn_rad']
}
},
'kernel': {
'gaussian': { # connection probability based on distance
'p_center': args['pypy_conn_p_center'],
'sigma': args['pypy_conn_p_sigma']
}
},
'weights': {
'gaussian': { # weight of connection based on distance
'p_center': args['pypy_conn_weight_center'],
'sigma': args['pypy_conn_weight_sigma'],
'min': 0.0
}
}
}
sample_size = args['sample_size'] # number of neurons to randomly sample
np.random.seed(args['seed']) # set numpy seed for reproducability
nest.ResetKernel() # reset NEST
nest.SetKernelStatus({'local_num_threads': 3}) # threading for efficiency
###########################################
#### NETWORK SETUP ####################
###########################################
# Create layers
layers = {
'stim': topp.CreateLayer(stim_layer_param),
'pyr': topp.CreateLayer(pyr_layer_param),
'inh': topp.CreateLayer(inh_layer_param)
}
# Connect layers
topp.ConnectLayers(layers['stim'], layers['pyr'], stim_conn_param)
topp.ConnectLayers(layers['pyr'], layers['inh'], pyr_conn_param)
topp.ConnectLayers(layers['inh'], layers['pyr'], inh_conn_param)
topp.ConnectLayers(layers['pyr'], layers['pyr'], pypy_conn_param)
# Connect spike detectors to random recording neurons
spk_det = {
'pyr': nest.Create('spike_detector'),
'inh': nest.Create('spike_detector')
}
rec_neurons = {
'pyr':
np.random.choice(nest.GetNodes(layers['pyr'])[0],
size=sample_size,
replace=False).tolist(),
'inh':
np.random.choice(nest.GetNodes(layers['inh'])[0],
size=sample_size,
replace=False).tolist()
}
for n in spk_det.keys():
nest.Connect(rec_neurons[n], spk_det[n])
###########################################
#### SIMULATION #######################
###########################################
# Initialize dictionary of firing rates
firing_rates = {
'pyr': [[] for i in range(sample_size)],
'inh': [[] for i in range(sample_size)]
}
for freq in range(freq_num):
nest.ResetNetwork()
nest.SetKernelStatus({'time': 0.0})
rt.live_update(freq, sim_num, var_id)
# Set rate for stim_layer neurons based on frequency of stimulus
for row in range(amp_factor):
for col in range(max(0, freq - tun_rad),
min(freq_num, freq + tun_rad + 1)):
rate_fac = max(0.0,
(tun_rad - abs(freq - col)) / float(tun_rad))
nest.SetStatus(topp.GetElement(layers['stim'], [col, row]),
{'rate': rate_fac * base_stim_rate})
# Simulate and record event data from spike detectors
nest.Simulate(sim_time)
# Store firing rate data for each set of neurons
for n in spk_det.keys():
sender_fires = [0] * sample_size
for i in nest.GetStatus(spk_det[n])[0]['events']['senders']:
sender_fires[rec_neurons[n].index(i)] += 1
for i in range(sample_size):
firing_rates[n][i].append(1000 * sender_fires[i] / sim_time)
# Reset rates for stim_layer neurons
for row in range(amp_factor):
for col in range(max(0, freq - tun_rad),
min(freq_num, freq + tun_rad + 1)):
nest.SetStatus(topp.GetElement(layers['stim'], [col, row]),
{'rate': 0.0})
return firing_rates
def simulation(Params):
root_folder = Params['root_folder']
if not os.path.isdir(root_folder):
os.makedirs(root_folder)
net_folder = root_folder + Params['net_folder']
if not os.path.isdir(net_folder):
os.makedirs(net_folder)
conn_folder = net_folder + '/connections'
if not os.path.isdir(conn_folder):
os.makedirs(conn_folder)
data_folder = net_folder + Params['data_folder']
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
#! =================
#! Import network
#! =================
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({"local_num_threads": Params['threads'],'resolution': Params['resolution']})
nest.SetStatus([0],{'print_time': True})
# initialize random seed
import time
msd = int(round(time.time() * 1000))
nest.SetKernelStatus({'grng_seed' : msd})
# Tom debug
# nest.SetKernelStatus({'rng_seeds' : range(msd+Params['threads']+1, msd+2*Params['threads']+1)})
nest.SetKernelStatus({'rng_seeds': range(msd + Params['threads'] + 1, msd + 2 * Params['threads'] + 1)})
import importlib
network = importlib.import_module(Params['network'])
reload(network)
models, layers, conns = network.get_Network(Params)
#import network_full_keiko
#reload(network_full_keiko)
# models, layers, conns = network_full_keiko.get_Network(Params)
# TODO this should come from network file
synapse_models = ['AMPA_syn', 'NMDA_syn', 'GABA_A_syn', 'GABA_B_syn', 'reticular_projection']
# synapse_models = ['AMPA_syn', 'NMDA_syn', 'GABA_A_syn', 'GABA_B_syn']
# Create models
print('Creating models...', end="")
for m in models:
print('.', end="")
# print(m), print('\n')
nest.CopyModel(m[0], m[1], m[2])
print(' done.')
# Create layers, store layer info in Python variable
print('Creating layers...', end="")
for l in layers:
print('.', end="")
exec '%s = tp.CreateLayer(l[1])' % l[0] in globals(), locals()
print(' done.')
# now either create brand new connections, or load connectivity files from
# connections_file
connections_file = conn_folder + '/connections.pickle'
# assume alread runned before, and it is going to load connections and layers
if Params.has_key('load_connections') and Params['load_connections']:
if not os.path.isfile(connections_file):
raise IOError('File with connections was never created: %s' % connections_file)
print('Loading connections...', end="")
with open(connections_file) as f:
(pre, post_intact, post_scrambled, w, d, syn) = pickle.load(f)
print(' done.')
if Params['scrambled']:
post = post_scrambled
else:
post = post_intact
print('Connecting neurons...', end="")
con_dict = {'rule': 'one_to_one'}
for (pi, ti, wi, di, syni) in zip(pre, post, w, d, syn):
print('.', end="")
# print(syni)
syn_dict = {"model": syni,
'weight': wi,
'delay': di
}
nest.Connect(pi, ti, con_dict, syn_dict)
print(' done.')
# print('Connection retina...', end="")
# # Create connections, need to insert variable names
# for c in conns:
# if c[0]=='Retina_layer':
# eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
# print('done.')
else:
# Create connections, need to insert variable names
print('Creating connections...', end="")
for c in conns:
if Params['Np'] < 40:
print('%s -> %s' % (c[0], c[1]))
c[2]['allow_oversized_mask'] = True
else:
print('.', end="")
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
print(' done.')
if Params.has_key('dump_connections') and Params['dump_connections']:
import glob
# First dump all nodes and connections to files
for l in layers:
print('dumping connections for %s' % l[0])
eval("tp.DumpLayerNodes(%s, conn_folder + '/nodes_%s.dump')" % (l[0], l[0]) )
for synapse in synapse_models:
eval("tp.DumpLayerConnections(%s, '%s', conn_folder + '/connections_%s_%s.dump')" % (l[0], synapse, l[0], synapse) )
# Now load all nodes, and mark which physical layer they belong to
all_nodes_files = glob.glob(conn_folder + "/nodes_*.dump")
if len(all_nodes_files) < 1:
raise ValueError('No files save for this configuration. First '
'run with load_connection = False')
pop_nodes = [None] * len(all_nodes_files)
pop_names = [None] * len(all_nodes_files)
perm_pop_nodes = [None] * len(all_nodes_files)
for (idx, pop_file) in enumerate(all_nodes_files):
population = pop_file[pop_file.find('nodes_')+6:-5]
pop_names[idx] = population
print('Loading nodes for population %s' % population)
pop_nodes[idx] = np.loadtxt(pop_file)
# identify physical layers
n_layer = 0
n_nodes = pop_nodes[idx].shape[0]
layers = np.zeros((n_nodes,1))
for i_line in range(n_nodes):
if pop_nodes[idx][i_line, 1] == -3.9 and pop_nodes[idx][i_line, 2] == 3.9:
n_layer += 1
layers[i_line] = n_layer
pop_nodes[idx] = np.append(pop_nodes[idx], layers, 1)
# Finally, load connections and save a big vector for each one of the 5
# parameters needed by nest.Connect: pre, post, w, d, and synapse_model
# Save unmodified and scrambled versions in network.pickle
all_conn_files = glob.glob(conn_folder + "/connections_*.dump")
pre = []
post_intact = []
post_scrambled = []
w = []
d = []
syn = []
for (idx, pop_conn_file) in enumerate(all_conn_files):
population = pop_conn_file[pop_conn_file.find('connections_')+12:-5]
print('Scrambling connections for %s (%d out of %d files)' % (population, idx+1, len(all_conn_files)))
synapse_model = [s for i,s in enumerate(synapse_models) if s in population][0]
print('Loading file')
pop_conns = np.loadtxt(pop_conn_file)
tn_lines = pop_conns.shape[0]
if tn_lines > 0:
syn.append(synapse_model)
pre.append(pop_conns[:,0].astype(int))
post_intact.append(pop_conns[:,1].astype(int))
w.append(pop_conns[:,2])
d.append(pop_conns[:,3].astype(int))
# Do the actual scrfambling
# TODO this should be optimized, it is way too slow
if any(w == population[0:2] for w in ['Vs', 'Vp']):
print('Scrambling...', end="")
for i_line in range(tn_lines):
if not i_line % round(tn_lines/10.):
print('%d%%, ' % (round(100.*i_line/tn_lines) if i_line > 0 else 0), end="")
for (i_pop, this_pop) in enumerate(pop_nodes):
t_idx = np.where(this_pop[:,0] == pop_conns[i_line, 1])[0]
if t_idx.size:
break
if not t_idx.size:
raise ValueError('Could not find tartget %s for node %s' % (pop_conns[i_line, 1], pop_conns[i_line, 0]))
if len(t_idx) > 1:
raise ValueError('Target %s apears in more than one population' % (pop_conns[i_line, 1], pop_conns[i_line, 0]))
new_t_idx = t_idx[0]
# For the moment, only scramble connections within the visual cortex
if any(w == pop_names[i_pop][0:2] for w in ['Vs', 'Vp']):
possible_targets = pop_nodes[i_pop][pop_nodes[i_pop][:,3] == pop_nodes[i_pop][new_t_idx,3], 0]
pop_conns[i_line, 1] = np.random.permutation(possible_targets)[0]
print('done.')
post_scrambled.append(pop_conns[:,1].astype(int))
# save results
print('Saving results...', end="")
with open(connections_file, 'w') as f:
pickle.dump((pre, post_intact, post_scrambled, w, d, syn), f)
print(' done.')
if Params.has_key('show_V4_num_conn_figure') and Params['show_V4_num_conn_figure']:
horizontal_nodes = nest.GetLeaves(Vp_horizontal, properties={'model': 'L4_exc'}, local_only=True)[0]
vertical_nodes = nest.GetLeaves(Vp_vertical, properties={'model': 'L4_exc'}, local_only=True)[0]
n_conns_hor = []
for (idx, horizontal_node) in enumerate(horizontal_nodes):
tgt_map = []
this_conns = nest.GetConnections([horizontal_node], horizontal_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_hor.append(len(tgt_map))
plt.figure()
plt.hist(n_conns_hor, range(0, max(n_conns_hor + [30])))
plt.title('# of connections Vp(h) L4pyr -> Vp(h) L4Pyr')
n_conns_hor = []
for (idx, horizontal_node) in enumerate(horizontal_nodes):
tgt_map = []
this_conns = nest.GetConnections([horizontal_node], vertical_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_hor.append(len(tgt_map))
# nest.DisconnectOneToOne(tp_node, tgt_map[0], {"synapse_model": "AMPA_syn"})
#nest.Disconnect([tp_node], tgt_map, 'one_to_one', {"synapse_model": "AMPA_syn"})
plt.figure()
plt.hist(n_conns_hor, range(0, max(n_conns_hor + [30])))
plt.title('# of connections Vp(h) L4pyr -> Vp(v) L4Pyr')
n_conns_ver = []
for (idx, vertical_node) in enumerate(vertical_nodes):
tgt_map = []
this_conns = nest.GetConnections([vertical_node], vertical_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_ver.append(len(tgt_map))
plt.figure()
plt.hist(n_conns_ver, range(0, max(n_conns_ver + [30])))
plt.title('# of connections Vp(v) L4pyr -> Vp(v) L4Pyr')
n_conns_ver = []
for (idx, vertical_node) in enumerate(vertical_nodes):
tgt_map = []
this_conns = nest.GetConnections([vertical_node], horizontal_nodes, synapse_model='AMPA_syn')
tgt_map.extend([conn[1] for conn in this_conns])
n_conns_ver.append(len(tgt_map))
plt.figure()
plt.hist(n_conns_ver, range(0, max(n_conns_ver + [30])))
plt.title('# of connections Vp(v) L4pyr -> Vp(h) L4Pyr')
plt.show()
# Check connections
if Params.has_key('show_center_connectivity_figure') and Params['show_center_connectivity_figure']:
# this code only gives one element, and you have no control over the
# model it comes from...
# tp.PlotTargets(tp.FindCenterElement(Vp_horizontal), Vp_horizontal, 'L56_exc', 'AMPA_syn')
# tp.PlotTargets(tp.FindCenterElement(Vp_horizontal), Vp_vertical, 'L56_exc', 'AMPA_syn')
# tp.PlotTargets(tp.FindCenterElement(Vp_vertical), Vp_horizontal, 'L56_exc', 'AMPA_syn')
# tp.PlotTargets(tp.FindCenterElement(Vp_vertical), Vp_vertical, 'L56_exc', 'AMPA_syn')
# this way I can get all nodes in the positions, and later filter per Model using GetStatus
# IMPORTANT: when layer has even number of neurons per line/column
# using center (0,0) makes the function return 4 neurons
# per postiion since they all have the same distance.
# Using (-0,1, 0,1) solves this problem.
# When using odd number perhaps this has to change...
for src_label in ['Tp_layer', 'Vp_vertical', 'Vp_horizontal']:
for tgt_label in ['Tp_layer', 'Vp_vertical', 'Vp_horizontal']:
if src_label == 'Tp_layer' and src_label == tgt_label:
continue
print('source population %s' % src_label)
print('target population %s' % tgt_label)
n_plot = 0
f = plt.figure()
f.canvas.set_window_title('AMPA Connections: %s -> %s' % (src_label, tgt_label))
all_center = eval('tp.FindNearestElement(%s, (-0.1, 0.1), True)[0]' % src_label)
for n in all_center:
s = nest.GetStatus([n])
p = tp.GetPosition([n])
# print('%s : (%2.2f, %2.2f)' % (s[0]['model'], p[0][0], p[0][1]))
m1 = s[0]['model'].name
print('Source neuron model %s' % m1)
if m1.find('_exc') > -1:
if src_label.find('Tp_') > -1:
print( 'found Tp_')
# target has to be one of Vp_ or Vs_ models
target_models = ['L23_exc', 'L4_exc', 'L56_exc']
elif src_label.find('Vp_') > -1 or src_label.find('Vs') > -1:
# if target is Vp_ of Vs_ too, then one of those models
if tgt_label.find('Vp_') > -1:
target_models = ['L23_exc', 'L4_exc', 'L56_exc']
elif tgt_label.find('Tp_') > -1:
# otherwise it has to be a Tp_target
target_models = ['Tp_exc']
else:
raise ValueError('Invalide target %s for source model: %s' % (tgt_label, src_label))
else:
raise ValueError('Invalide source model: %s' % (src_label))
for m2 in target_models:
print('Target neuron model %s' % m2)
try:
get_targets_command = 'tp.GetTargetNodes([n], %s, m2, "AMPA_syn")[0]' % tgt_label
print(get_targets_command)
targets = eval(get_targets_command)
if len(targets) > 0:
n_plot += 1
f.add_subplot(3,5,n_plot)
eval('tp.PlotTargets([n], %s, m2, "AMPA_syn", f)' % tgt_label)
plt.title('%s -> %s' % (m1, m2), fontsize=9)
except:
print('didnt work')
f.savefig(data_folder + '/connectivity_%s_%s.png' % (src_label, tgt_label), dpi=100)
if Params.has_key('show_V4_connectivity_figure') and Params['show_V4_connectivity_figure']:
Vp_hor_gids = tp.GetElement(Vp_horizontal, [0,0])
n_Vp_hor = len(Vp_hor_gids)
f = []
for idx in range(n_Vp_hor):
f.append(plt.figure())
positions = range(0,41,10)
positions[-1] -= 1
for xi in range(len(positions)):
for yi in range(len(positions)):
print("Position [%d,%d] : %d" %(xi,yi,yi*(len(positions))+xi+1))
x = positions[xi]
y = positions[yi]
Vp_hor_gids = tp.GetElement(Vp_horizontal, [x,y])
Vp_hor_status = nest.GetStatus(Vp_hor_gids)
for (idx, n) in enumerate(Vp_hor_status):
if n['Tau_theta'] == 2.0:
print(idx)
try:
f[idx].add_subplot(len(positions), len(positions), yi*(len(positions))+xi+1)
tp.PlotTargets([Vp_hor_gids[idx]], Vp_horizontal, 'L4_exc', 'AMPA_syn', f[idx])
except:
print('%i bad' % Vp_hor_gids[idx])
plt.show()
if Params.has_key('dry_run') and Params['dry_run']:
print('Only generation, loading and ploting network. No actual simulation done.')
return
'''
# pablo
# Create vertical grating
for n in nest.GetLeaves(Retina_layer)[0]:
retina_0 = (nest.GetLeaves(Retina_layer)[0])[0]
col = (n-retina_0)/Params['Np']
cells_per_degree = Params['Np']/Params['visSize']
cells_per_cycle = cells_per_degree/Params['spatial_frequency']
nest.SetStatus([n], { "phase": col * 360/(cells_per_cycle-1) })
'''
### keiko
if Params['lambda_dg'] >= 0:
[nest.SetStatus([n], {"phase": phaseInit(tp.GetPosition([n])[0],
Params["lambda_dg"],
Params["phi_dg"])})
for n in nest.GetLeaves(Retina_layer)[0]]
else:
# Leonardo: Random retina input
[nest.SetStatus([n], {"phase": phaseInit(tp.GetPosition([n])[0],
np.pi * np.random.rand(),
np.pi * np.random.rand())})
for n in nest.GetLeaves(Retina_layer)[0]]
# --------------------------------------------------------------------#
# ---------- SET IB NEURONS ----------------------------------------- #
# --------------------------------------------------------------------#
# 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron.
# That is achieved by setting pacemaker current I_h.
# So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0.
# (Other cortical neuron do not have I_h, thus h_g_peak=0.0)
L56_vertical_idx = [nd for nd in nest.GetLeaves(Vp_vertical)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
L56_horizontal_idx = [nd for nd in nest.GetLeaves(Vp_horizontal)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
num_neuron = len(L56_vertical_idx)
num_ib = int(num_neuron*0.3)
ridx_vertical = np.random.randint(num_neuron, size=(1,num_ib))[0]
ridx_horizontal = np.random.randint(num_neuron, size=(1,num_ib))[0]
for i in range(1,num_ib,1):
nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'g_peak_h': 1.0})
nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]], {'g_peak_h': 1.0})
# initiate network activity
#nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(500.0)
#! =================
#! Recording devices
#! =================
print('Connecting recorders...', end="")
nest.CopyModel('multimeter', 'RecordingNode',
params = {'interval' : Params['resolution'],
'record_from': ['V_m'],#,
# Put back when plotting synaptic currents, otherwise makes everything slower for no reason
# 'I_syn_AMPA',
# 'I_syn_NMDA',
# 'I_syn_GABA_A',
# 'I_syn_GABA_B',
# 'g_AMPA',
# 'g_NMDA',
# 'g_GABA_A',
# 'g_GABA_B'],
#'I_NaP',
#'I_KNa',
#'I_T',
#'I_h'
#]
'record_to' : ['memory'],
'withgid' : True,
'withtime' : True})
recorders = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh')]:
'''
# for population, model in [(Retina_layer, 'Retina'),
# (Tp_layer , 'Tp_exc'),
# (Tp_layer , 'Tp_inh'),
# (Vp_vertical, 'L4_exc'),
# (Vp_vertical, 'L4_inh'),
# (Vp_horizontal, 'L4_exc'),
# (Vp_vertical, 'L23_exc'),
# (Vp_horizontal, 'L23_exc'),
# (Vp_vertical, 'L56_exc'),
# (Rp_layer, 'Rp')]:
for population, model in [(Retina_layer, 'Retina'),
# (Tp_layer , 'Tp_exc'),
# (Tp_layer , 'Tp_inh'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_exc'),
(Vp_horizontal, 'L23_exc'),
# (Rp_layer, 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_vertical, 'L4_exc'),
(Vp_vertical, 'L56_exc'),
(Vs_vertical, 'L23_exc'),
(Vs_vertical, 'L4_exc'),
(Vs_vertical, 'L56_exc'),
]:
print('.', end="")
rec = nest.Create('RecordingNode')
recorders.append([rec,population,model])
if (model=='Retina'):
nest.SetStatus(rec,{'record_from': ['rate']})
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
#nest.Connect(rec, tgts, None, {'delay': recorders_delay})
nest.Connect(rec, tgts)
print('done.')
#! =================
#! Spike detector
#! =================
print('Connecting detectors...', end="")
detectors = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh')]:
'''
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc')]:
'''
#Tom
for population, model in [(Retina_layer, 'Retina'),
# (Tp_layer, 'Tp_exc'),
# (Tp_layer, 'Tp_inh'),
(Vp_vertical, 'L23_exc'),
(Vp_vertical, 'L4_exc'),
(Vp_vertical, 'L56_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_vertical, 'L4_inh'),
(Vp_vertical, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_vertical, 'L56_inh')]:
print('.', end="")
rec = nest.Create('spike_detector', params={"withgid": True, "withtime": True})
#rec = nest.Create('spike_detector')
detectors.append([rec,population,model])
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
if model == 'Retina':
for t in tgts:
try:
# nest.Connect([t], rec, None, {'delay': recorders_delay})
nest.Connect([t], rec)
print('connected %d' % t)
except:
print('%d did not work' % t)
else:
# nest.Connect(tgts, rec, None, {'delay': recorders_delay})
nest.Connect(tgts, rec)
print('done.')
#! ====================
#! Simulation
#! ====================
'''
# change gKL to 0.8 in all populations (necessary to get a little stronger evoked response)
for l in layers:
sim_elements = l[1]['elements']
for m in np.arange(0,np.size(sim_elements),1):
if(np.size(sim_elements)==1):
sim_model = sim_elements
else:
sim_model = sim_elements[m]
exec("la = %s" % l[0])
pop = [nd for nd in nest.GetLeaves(la)[0] if nest.GetStatus([nd], 'model')[0]==sim_model]
if (l[0]!='Retina_layer'):
for cell in pop:
nest.SetStatus([cell], {'g_KL':0.8})
'''
# Simulate
for t in Params['intervals']:
#if (t == 250.0): # Stimulus ON
# # if (t == 1500.0): # Stimulus ON
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 45.0})
#else: # Stimulus OFF
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
if Params['input_flag']==True:
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': Params['ret_rate']})
else:
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(t)
#! ====================
#! Plot Results
#! ====================
print("Creating figure 3...")
rows = 9
cols = 2
fig = plt.figure(num=None, figsize=(13, 24), dpi=100)
fig.subplots_adjust(hspace=0.4)
# Plot A: membrane potential rasters
recorded_models = [(Retina_layer,'Retina'),
(Vp_vertical,'L23_exc'),
(Vp_vertical,'L4_exc'),
(Vp_vertical,'L56_exc'),
(Vs_vertical,'L23_exc'),
(Vs_vertical,'L4_exc')]
#plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
rows,cols,0)
#starting_neuron = 800+1
#plotting.potential_raster(fig,recorders,recorded_models,starting_neuron,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plt.title('Evoked')
# Plot B: individual intracellular traces
recorded_models =[(Vp_vertical,'L4_exc'),
(Vp_vertical,'L4_inh')]
#plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6) #original
# keiko
total_time = 0.0
for t in Params['intervals']:
total_time += t
#draw_neuron = (Params['Np']*Params['Np']/2)
#plotting.intracellular_potentials(fig, recorders, recorded_models, draw_neuron, rows, cols, 6, total_time)
plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6, total_time)
#plotting.intracellular_potentials(fig, recorders, recorded_models, 820, rows, cols, 6, total_time)
# Plot C: topographical activity of the vertical and horizontal layers
if Params.has_key('start_membrane_potential') and Params.has_key('end_membrane_potential'):
start = Params['start_membrane_potential']
stop = Params['end_membrane_potential']
else:
start = 130.0
stop = 140.0
recorded_models = [(Vp_vertical,'L23_exc')]
labels = ["Vertical"]
plotting.topographic_representation(fig,
recorders,
recorded_models,
labels,
Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
rows,
cols,
start,
stop,
8,
0)
recorded_models = [(Vp_horizontal,'L23_exc')]
labels = ["Horizontal"]
plotting.topographic_representation(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,start,stop,8,1)
fig.savefig(data_folder + '/figure3.png', dpi=100)
if Params.has_key('show_main_figure') and Params['show_main_figure']:
plt.show()
# Plot D: movie
#labels = ["Evoked_Vp_L23_Vertical","Evoked_Vp_L23_Horizontal"]
#recorded_models = [(Vp_vertical,'L23_exc'),(Vp_horizontal,'L23_exc')]
#plotting.makeMovie(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'])
#! ====================
#! Save Results
#! ====================
print('save recorders data')
# Set folder
#rootdir = '/home/kfujii2/newNEST2/ht_model_pablo_based/data/'
#expdir = 'random/'
# expdir = 'random_full/'
# expdir = 'structured_full/'
# data_folder = rootdir + expdir
# To save spike data, set pairs of population id and its name
population_name = [ {'population': Retina_layer, 'name': 'Retina'},
{'population': Vp_vertical, 'name': 'Vp_v'},
{'population': Vp_horizontal, 'name': 'Vp_h'},
# {'population': Rp_layer, 'name': 'Rp'},
# {'population': Tp_layer, 'name': 'Tp'},
{'population': Vs_vertical, 'name': 'Vs_v'},
{'population': Vs_horizontal, 'name': 'Vs_h'}]
if Params.has_key('save_recorders') and Params['save_recorders']:
for rec, population, model in recorders:
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
data = nest.GetStatus(rec)[0]['events']
if model == 'Retina':
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'rate': data['rate']})
else:
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'times': data['times'],
'V_m': data['V_m'],
#'I_syn_AMPA': data['I_syn_AMPA'],
#'I_syn_NMDA': data['I_syn_NMDA'],
#'I_syn_GABA_A': data['I_syn_GABA_A'],
#'I_syn_GABA_B': data['I_syn_GABA_B'],
# 'g_AMPA': data['g_AMPA'],
# 'g_NMDA': data['g_NMDA'],
# 'g_GABA_A': data['g_GABA_A'],
# 'g_GABA_B': data['g_GABA_B']
} )
print('save raster images')
plt.close()
for rec, population, model in detectors:
spikes = nest.GetStatus(rec, 'events')[0]
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
if len(nest.GetStatus(rec)[0]['events']['senders']) > 3:
raster = raster_plot.from_device(rec, hist=True)
pylab.title( p_name + '_' + model )
f = raster[0].figure
f.set_size_inches(15, 9)
f.savefig(data_folder + '/spikes_' + p_name + '_' + model + '.png', dpi=100)
plt.close()
# Set filename and save spike data
filename = data_folder + '/spike_' + p_name + '_' + model + '.pickle'
pickle.dump(spikes, open(filename, 'w'))
scipy.io.savemat(data_folder + '/spike_' + p_name + '_' + model + '.mat', mdict={'senders': spikes['senders'], 'times': spikes['times']})
'''
filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat'
filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '.dat'
filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '.dat'
filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '.dat'
tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA)
tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA)
tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB)
'''
'''
for p in range(0, len(population_name), 1):
population = population_name[p]['population']
p_name = population_name[p]['name']
filename_nodes = data_folder + '/gid_' + p_name + '.dat'
tp.DumpLayerNodes(population, filename_nodes)
'''
network_script = Params['network'] + '.py'
shutil.copy2(network_script, data_folder + '/' + network_script)
shutil.copy2(network_script, conn_folder + '/' + network_script)
print('end')
def NESTSimulation(self,retina_spikes):
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus(
{"local_num_threads": self.Params['NEST_threads'],
'resolution': self.Params['resolution'], "rng_seeds": list(self.seeds)})
# import network description
import thalamocortical_system
# get network info
models, layers, conns = thalamocortical_system.get_Network(self.Params)
# Create models
for m in models:
nest.CopyModel(m[0], m[1], m[2])
print ("\n---Creating layers---\n")
# Create layers, store layer info in Python variable
layer_IDs = []
for l in layers:
exec ("%s = tp.CreateLayer(%s)" % (l[0],l[1]),globals())
exec ("copy_var = %s" % l[0],globals())
layer_IDs.append([l[0],copy_var,l[1]['elements']])
# print (l[0])
print ("\n---Connecting layers---\n")
# Create connections, need to insert variable names
for c in conns:
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
# print ('tp.ConnectLayers(%s,%s)' % (c[0], c[1]))
# Initialize spike generators
Midget_ganglion_cells_L_ON_spikes = retina_spikes[0]
Midget_ganglion_cells_L_OFF_spikes = retina_spikes[1]
Midget_ganglion_cells_M_ON_spikes = retina_spikes[2]
Midget_ganglion_cells_M_OFF_spikes = retina_spikes[3]
cell = 0
for x in np.arange(self.Params['N_LGN']):
for y in np.arange(self.Params['N_LGN']):
nest.SetStatus([tp.GetElement(Midget_ganglion_cells_L_ON,(x,y))[0]],
[{'spike_times':Midget_ganglion_cells_L_ON_spikes[cell],
'spike_weights':[]}])
nest.SetStatus([tp.GetElement(Midget_ganglion_cells_L_OFF,(x,y))[0]],
[{'spike_times':Midget_ganglion_cells_L_OFF_spikes[cell],
'spike_weights':[]}])
nest.SetStatus([tp.GetElement(Midget_ganglion_cells_M_ON,(x,y))[0]],
[{'spike_times':Midget_ganglion_cells_M_ON_spikes[cell],
'spike_weights':[]}])
nest.SetStatus([tp.GetElement(Midget_ganglion_cells_M_OFF,(x,y))[0]],
[{'spike_times':Midget_ganglion_cells_M_OFF_spikes[cell],
'spike_weights':[]}])
cell+=1
## Check-point: Visualization functions
# fig = tp.PlotLayer(Color_Luminance_inh_L_ON_L_OFF_vertical,nodesize =80)
# ctr = tp.FindCenterElement(Parvo_LGN_relay_cell_L_ON)
# tp.PlotTargets(ctr,Color_Luminance_inh_L_ON_L_OFF_vertical,fig = fig,mask=conns[26][2]['mask'],
# kernel=conns[26][2]['kernel'],src_size=250,tgt_color='red',tgt_size=20,
# kernel_color='green')
# plt.show()
# ctr = tp.FindCenterElement(Color_Luminance_inh_L_ON_L_OFF_vertical)
# print ("ctr = ",ctr," L-ON = ",tp.FindCenterElement(Parvo_LGN_relay_cell_L_ON)," L-OFF = ",tp.FindCenterElement(Parvo_LGN_relay_cell_L_OFF))
# for xx in np.arange(5):
# for yy in np.arange(5):
# ctr = [tp.GetElement(Color_Luminance_inh_L_ON_L_OFF_vertical,(xx,yy))[0]]
# conns = nest.GetConnections(target = [ctr[0]])
# print ("Cell ",ctr)
# for nn in np.arange(len(conns)):
# print ("conns = ",conns[nn])
# ctr = tp.FindCenterElement(Parvo_LGN_relay_cell_L_ON)
# targets = tp.GetTargetNodes(ctr,Color_Luminance_L_ON_L_OFF_vertical)
# print ("targets = ",targets)
return layer_IDs
def simulation(Params):
root_folder = Params['root_folder']
if not os.path.isdir(root_folder):
os.makedirs(root_folder)
net_folder = root_folder + Params['net_folder']
if not os.path.isdir(net_folder):
os.makedirs(net_folder)
data_folder = net_folder + Params['data_folder']
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
#! =================
#! Import network
#! =================
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({"local_num_threads": Params['threads'],'resolution': Params['resolution']})
nest.SetStatus([0],{'print_time': True})
# initialize random seed
import time
# msd = int(round(time.time() * 1000))
msd = 42
nest.SetKernelStatus({'grng_seed' : msd})
# Tom debug
# nest.SetKernelStatus({'rng_seeds' : range(msd+Params['threads']+1, msd+2*Params['threads']+1)})
nest.SetKernelStatus({'rng_seeds': range(msd + Params['threads'] + 1, msd + 2 * Params['threads'] + 1)})
import importlib
network = importlib.import_module(Params['network'])
reload(network)
models, layers, conns = network.get_Network(Params)
#import network_full_keiko
#reload(network_full_keiko)
# models, layers, conns = network_full_keiko.get_Network(Params)
# Create models
print('Creating models...', end="")
for m in models:
print('.', end="")
# print(m), print('\n')
nest.CopyModel(m[0], m[1], m[2])
print(' done.')
# Create layers, store layer info in Python variable
print('Creating layers...', end="")
for l in layers:
print('.', end="")
exec '%s = tp.CreateLayer(l[1])' % l[0] in globals(), locals()
print(' done.')
# Create connections, need to insert variable names
print('Creating connectiions...', end="")
for c in conns:
print('.', end="")
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
print(' done.')
# Check connections
if Params.has_key('show_center_connectivity_figure') and Params['show_center_connectivity_figure']:
# this code only gives one element, and you have no control over the
# model it comes from...
# tp.PlotTargets(tp.FindCenterElement(Vp_horizontal), Vp_horizontal, 'L56_exc', 'AMPA_syn')
# tp.PlotTargets(tp.FindCenterElement(Vp_horizontal), Vp_vertical, 'L56_exc', 'AMPA_syn')
# tp.PlotTargets(tp.FindCenterElement(Vp_vertical), Vp_horizontal, 'L56_exc', 'AMPA_syn')
# tp.PlotTargets(tp.FindCenterElement(Vp_vertical), Vp_vertical, 'L56_exc', 'AMPA_syn')
# this way I can get all nodes in the positions, and later filter per Model using GetStatus
# IMPORTANT: when layer has even number of neurons per line/column
# using center (0,0) makes the function return 4 neurons
# per postiion since they all have the same distance.
# Using (-0,1, 0,1) solves this problem.
# When using odd number perhaps this has to change...
for src_label in ['Tp_layer', 'Vp_vertical', 'Vp_horizontal']:
for tgt_label in ['Tp_layer', 'Vp_vertical', 'Vp_horizontal']:
if src_label == 'Tp_layer' and src_label == tgt_label:
continue
print('source population %s' % src_label)
print('target population %s' % tgt_label)
n_plot = 0
f = plt.figure()
f.canvas.set_window_title('AMPA Connections: %s -> %s' % (src_label, tgt_label))
all_center = eval('tp.FindNearestElement(%s, (-0.1, 0.1), True)[0]' % src_label)
for n in all_center:
s = nest.GetStatus([n])
p = tp.GetPosition([n])
# print('%s : (%2.2f, %2.2f)' % (s[0]['model'], p[0][0], p[0][1]))
m1 = s[0]['model'].name
print('Source neuron model %s' % m1)
if m1.find('_exc') > -1:
if src_label.find('Tp_') > -1:
print( 'found Tp_')
# target has to be one of Vp_ or Vs_ models
target_models = ['L23_exc', 'L4_exc', 'L56_exc']
elif src_label.find('Vp_') > -1 or src_label.find('Vs') > -1:
# if target is Vp_ of Vs_ too, then one of those models
if tgt_label.find('Vp_') > -1:
target_models = ['L23_exc', 'L4_exc', 'L56_exc']
elif tgt_label.find('Tp_') > -1:
# otherwise it has to be a Tp_target
target_models = ['Tp_exc']
else:
raise ValueError('Invalide target %s for source model: %s' % (tgt_label, src_label))
else:
raise ValueError('Invalide source model: %s' % (src_label))
for m2 in target_models:
print('Target neuron model %s' % m2)
try:
get_targets_command = 'tp.GetTargetNodes([n], %s, m2, "AMPA_syn")[0]' % tgt_label
print(get_targets_command)
targets = eval(get_targets_command)
if len(targets) > 0:
n_plot += 1
f.add_subplot(3,5,n_plot)
eval('tp.PlotTargets([n], %s, m2, "AMPA_syn", f)' % tgt_label)
plt.title('%s -> %s' % (m1, m2), fontsize=9)
except:
print('didnt work')
f.savefig(data_folder + '/connectivity_%s_%s.png' % (src_label, tgt_label), dpi=100)
if Params.has_key('dry_run') and Params['dry_run']:
print('Only generation, loading and ploting network. No actual simulation done.')
return
'''
# pablo
# Create vertical grating
for n in nest.GetLeaves(Retina_layer)[0]:
retina_0 = (nest.GetLeaves(Retina_layer)[0])[0]
col = (n-retina_0)/Params['Np']
cells_per_degree = Params['Np']/Params['visSize']
cells_per_cycle = cells_per_degree/Params['spatial_frequency']
nest.SetStatus([n], { "phase": col * 360/(cells_per_cycle-1) })
'''
### keiko
[nest.SetStatus([n], {"phase": phaseInit(tp.GetPosition([n])[0],
Params["lambda_dg"],
Params["phi_dg"])})
for n in nest.GetLeaves(Retina_layer)[0]]
# --------------------------------------------------------------------#
# ---------- SET IB NEURONS ----------------------------------------- #
# --------------------------------------------------------------------#
# 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron.
# That is achieved by setting pacemaker current I_h.
# So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0.
# (Other cortical neuron do not have I_h, thus h_g_peak=0.0)
L56_vertical_idx = [nd for nd in nest.GetLeaves(Vp_vertical)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
L56_horizontal_idx = [nd for nd in nest.GetLeaves(Vp_horizontal)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
num_neuron = len(L56_vertical_idx)
num_ib = int(num_neuron*0.3)
ridx_vertical = np.random.randint(num_neuron, size=(1,num_ib))[0]
ridx_horizontal = np.random.randint(num_neuron, size=(1,num_ib))[0]
for i in range(1,num_ib,1):
nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'g_peak_h': 1.0})
nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]], {'g_peak_h': 1.0})
# initiate network activity
#nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': Params['ret_rate']})
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(500.0)
#! =================
#! Recording devices
#! =================
print('Connecting recorders...', end="")
nest.CopyModel('multimeter', 'RecordingNode',
params = {'interval' : Params['resolution'],
'record_from': ['V_m'],
# Put back when plotting synaptic currents, otherwise makes everything slower for no reason
# 'I_syn_AMPA',
# 'I_syn_NMDA',
# 'I_syn_GABA_A',
# 'I_syn_GABA_B',
# 'g_AMPA',
# 'g_NMDA',
# 'g_GABA_A',
# 'g_GABA_B'],
#'I_NaP',
#'I_KNa',
#'I_T',
#'I_h'
#]
'record_to' : ['memory'],
'withgid' : True,
'withtime' : True})
recorders = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh'),
(Vs_cross, 'L23_exc'),
(Vs_cross, 'L4_exc'),
(Vs_cross, 'L4_exc'),
]:
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_cross, 'L23_exc'),
(Vs_cross, 'L4_exc'),
(Vs_cross, 'L56_exc'),
]:
print('.', end="")
rec = nest.Create('RecordingNode')
recorders.append([rec,population,model])
if (model=='Retina'):
nest.SetStatus(rec,{'record_from': ['rate']})
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
#nest.Connect(rec, tgts, None, {'delay': recorders_delay})
nest.Connect(rec, tgts)
print('done.')
#! =================
#! Spike detector
#! =================
print('Connecting detectors...', end="")
detectors = []
'''
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'),
(Vp_horizontal, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_horizontal, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_horizontal, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_vertical, 'L56_inh'),
(Vs_horizontal, 'L56_inh')]:
'''
#Tom
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer, 'Tp_exc'),
(Tp_layer, 'Tp_inh'),
(Vp_vertical, 'L23_exc'),
(Vp_vertical, 'L4_exc'),
(Vp_vertical, 'L56_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_vertical, 'L4_inh'),
(Vp_vertical, 'L56_inh'),
(Vs_vertical, 'L23_exc'),
(Vs_vertical, 'L23_inh'),
(Vs_vertical, 'L4_exc'),
(Vs_vertical, 'L4_inh'),
(Vs_vertical, 'L56_exc'),
(Vs_vertical, 'L56_inh')]:
print('.', end="")
rec = nest.Create('spike_detector', params={"withgid": True, "withtime": True})
#rec = nest.Create('spike_detector')
detectors.append([rec,population,model])
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
if model == 'Retina':
for t in tgts:
try:
# nest.Connect([t], rec, None, {'delay': recorders_delay})
nest.Connect([t], rec)
print('connected %d' % t)
except:
print('%d did not work' % t)
else:
# nest.Connect(tgts, rec, None, {'delay': recorders_delay})
nest.Connect(tgts, rec)
print('done.')
#! ====================
#! Simulation
#! ====================
'''
# change gKL to 0.8 in all populations (necessary to get a little stronger evoked response)
for l in layers:
sim_elements = l[1]['elements']
for m in np.arange(0,np.size(sim_elements),1):
if(np.size(sim_elements)==1):
sim_model = sim_elements
else:
sim_model = sim_elements[m]
exec("la = %s" % l[0])
pop = [nd for nd in nest.GetLeaves(la)[0] if nest.GetStatus([nd], 'model')[0]==sim_model]
if (l[0]!='Retina_layer'):
for cell in pop:
nest.SetStatus([cell], {'g_KL':0.8})
'''
# Simulate
for t in Params['intervals']:
#if (t == 250.0): # Stimulus ON
# # if (t == 1500.0): # Stimulus ON
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 45.0})
#else: # Stimulus OFF
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
if Params['input_flag']==True:
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': Params['ret_rate']})
else:
nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(t)
#! ====================
#! Plot Results
#! ====================
print("Creating figure 3...")
rows = 9
cols = 2
fig = plt.figure(num=None, figsize=(13, 24), dpi=100)
fig.subplots_adjust(hspace=0.4)
# Plot A: membrane potential rasters
recorded_models = [(Retina_layer,'Retina'),
(Vp_vertical,'L23_exc'),
(Vp_vertical,'L4_exc'),
(Vp_vertical,'L56_exc'),
(Rp_layer,'Rp'),
(Tp_layer,'Tp_exc')]
#plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
rows,cols,0)
#starting_neuron = 800+1
#plotting.potential_raster(fig,recorders,recorded_models,starting_neuron,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plt.title('Evoked')
# Plot B: individual intracellular traces
recorded_models =[(Vp_vertical,'L4_exc'),
(Vp_vertical,'L4_inh')]
#plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6) #original
# keiko
total_time = 0.0
for t in Params['intervals']:
total_time += t
#draw_neuron = (Params['Np']*Params['Np']/2)
#plotting.intracellular_potentials(fig, recorders, recorded_models, draw_neuron, rows, cols, 6, total_time)
plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6, total_time)
#plotting.intracellular_potentials(fig, recorders, recorded_models, 820, rows, cols, 6, total_time)
# Plot C: topographical activity of the vertical and horizontal layers
if Params.has_key('start_membrane_potential') and Params.has_key('end_membrane_potential'):
start = Params['start_membrane_potential']
stop = Params['end_membrane_potential']
else:
start = 130.0
stop = 140.0
recorded_models = [(Vp_vertical,'L23_exc')]
labels = ["Vertical"]
plotting.topographic_representation(fig,
recorders,
recorded_models,
labels,
Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
rows,
cols,
start,
stop,
8,
0)
recorded_models = [(Vp_horizontal,'L23_exc')]
labels = ["Horizontal"]
plotting.topographic_representation(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,start,stop,8,1)
if Params.has_key('figure_title'):
fig.suptitle(Params['figure_title'], size = 20)
fig.savefig(data_folder + '/figure3.png', dpi=100)
if Params.has_key('show_main_figure') and Params['show_main_figure']:
plt.show()
# Plot D: movie
#labels = ["Evoked_Vp_L23_Vertical","Evoked_Vp_L23_Horizontal"]
#recorded_models = [(Vp_vertical,'L23_exc'),(Vp_horizontal,'L23_exc')]
#plotting.makeMovie(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'])
# Plot F: All areas
if Params.has_key('plot_all_regions') and Params['plot_all_regions']:
print("Creating plot of all cortical areas")
#First column
vertical_models = [(Retina_layer,'Retina'),
(Vp_vertical,'L23_exc'),
(Vp_vertical,'L4_exc'),
(Vp_vertical,'L56_exc'),
(Vs_vertical,'L23_exc'),
(Vs_vertical, 'L4_exc'),
(Vs_vertical, 'L56_exc')]
#Second column
horizontal_models = [(Retina_layer,'Retina'),
(Vp_horizontal,'L23_exc'),
(Vp_horizontal,'L4_exc'),
(Vp_horizontal,'L56_exc'),
(Vs_horizontal,'L23_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_horizontal, 'L56_exc')]
#Third column
cross_models = [(Retina_layer,'Retina'),
(),
(),
(),
(Vs_cross,'L23_exc'),
(Vs_cross, 'L4_exc'),
(Vs_cross, 'L56_exc')]
#Column labels
labels = ['Vertical', 'Horizontal', 'Cross']
#Row labels
areas = ['Retina', 'Primary\nL2/3', 'Primary\nL4', 'Primary\nL5/6', 'Secondary\nL2/3', 'Secondary\nL4', 'Secondary\nL4/6']
plotcols = [vertical_models, horizontal_models, cross_models]
fig = plotting.potential_raster_multiple_models(fig, recorders, plotcols, labels, areas, 0, Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
0)
fig.savefig(data_folder + '/figure_all_areas.png', dpi=100)
#! ====================
#! Save Results
#! ====================
print('save recorders data')
# Set folder
#rootdir = '/home/kfujii2/newNEST2/ht_model_pablo_based/data/'
#expdir = 'random/'
# expdir = 'random_full/'
# expdir = 'structured_full/'
# data_folder = rootdir + expdir
# To save spike data, set pairs of population id and its name
population_name = [ {'population': Retina_layer, 'name': 'Retina'},
{'population': Vp_vertical, 'name': 'Vp_v'},
{'population': Vp_horizontal, 'name': 'Vp_h'},
{'population': Rp_layer, 'name': 'Rp'},
{'population': Tp_layer, 'name': 'Tp'},
{'population': Vs_vertical, 'name': 'Vs_v'},
{'population': Vs_horizontal, 'name': 'Vs_h'}]
if Params.has_key('save_recorders') and Params['save_recorders']:
for rec, population, model in recorders:
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
data = nest.GetStatus(rec)[0]['events']
if model == 'Retina':
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'rate': data['rate']})
else:
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'times': data['times'],
'V_m': data['V_m'] #,
#'I_syn_AMPA': data['I_syn_AMPA'],
#'I_syn_NMDA': data['I_syn_NMDA'],
#'I_syn_GABA_A': data['I_syn_GABA_A'],
#'I_syn_GABA_B': data['I_syn_GABA_B'],
# 'g_AMPA': data['g_AMPA'],
# 'g_NMDA': data['g_NMDA'],
# 'g_GABA_A': data['g_GABA_A'],
# 'g_GABA_B': data['g_GABA_B']
} )
print('save raster images')
plt.close()
for rec, population, model in detectors:
spikes = nest.GetStatus(rec, 'events')[0]
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
if len(nest.GetStatus(rec)[0]['events']['senders']) > 3:
raster = raster_plot.from_device(rec, hist=True)
pylab.title( p_name + '_' + model )
f = raster[0].figure
f.set_size_inches(15, 9)
f.savefig(data_folder + '/spikes_' + p_name + '_' + model + '.png', dpi=100)
plt.close()
# Set filename and save spike data
filename = data_folder + '/spike_' + p_name + '_' + model + '.pickle'
pickle.dump(spikes, open(filename, 'w'))
scipy.io.savemat(data_folder + '/spike_' + p_name + '_' + model + '.mat', mdict={'senders': spikes['senders'], 'times': spikes['times']})
'''
filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat'
filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '.dat'
filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '.dat'
filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '.dat'
tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA)
tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA)
tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB)
'''
'''
for p in range(0, len(population_name), 1):
population = population_name[p]['population']
p_name = population_name[p]['name']
filename_nodes = data_folder + '/gid_' + p_name + '.dat'
tp.DumpLayerNodes(population, filename_nodes)
'''
network_script = Params['network'] + '.py'
shutil.copy2(network_script, data_folder + '/' + network_script)
print('end')
def simulation(Params):
#! =================
#! Import network
#! =================
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({"local_num_threads": Params['threads'],'resolution': Params['resolution']})
nest.SetStatus([0],{'print_time': True})
import network_full_keiko
reload(network_full_keiko)
models, layers, conns = network_full_keiko.get_Network(Params)
# Create models
for m in models:
nest.CopyModel(m[0], m[1], m[2])
# Create layers, store layer info in Python variable
for l in layers:
exec '%s = tp.CreateLayer(l[1])' % l[0]
# Create connections, need to insert variable names
for c in conns:
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
# --------------------------------------------------------------------#
# ---------- SET IB NEURONS ----------------------------------------- #
# --------------------------------------------------------------------#
# 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron.
# That is achieved by setting pacemaker current I_h.
# So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0.
# (Other cortical neuron do not have I_h, thus h_g_peak=0.0)
L56_vertical_idx = [nd for nd in nest.GetLeaves(Vp_vertical)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
L56_horizontal_idx = [nd for nd in nest.GetLeaves(Vp_horizontal)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
num_neuron = len(L56_vertical_idx)
num_ib = int(num_neuron*0.3)
ridx_vertical = np.random.randint(num_neuron, size=(1,num_ib))[0]
ridx_horizontal = np.random.randint(num_neuron, size=(1,num_ib))[0]
for i in range(1,num_ib,1):
nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'h_g_peak': 1.0})
nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]], {'h_g_peak': 1.0})
# ==============================
# initiate network activity
# ==============================
#nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'rate': 20.0})
#nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
#nest.Simulate(500.0)
'''
initiation_frate = 50
initiation_time = 500
for i in range(1, Params['Np']*Params['Np'], 1):
tmp_rand
nest.Simulate(initiation_time)
'''
#! =================
#! Recording devices
#! =================
nest.CopyModel('multimeter', 'RecordingNode',
params = {'interval' : Params['resolution'],
#'record_from': ['V_m'],
'record_from': ['V_m',
'I_syn_AMPA',
'I_syn_NMDA',
'I_syn_GABA_A',
'I_syn_GABA_B',
'g_AMPA',
'g_NMDA',
'g_GABAA',
'g_GABAB',
'I_NaP',
'I_KNa',
'I_T',
'I_h'],
'record_to' : ['memory'],
'withgid' : True,
'withtime' : True})
recorders = []
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc')]:
rec = nest.Create('RecordingNode')
recorders.append([rec,population,model])
if (model=='Retina'):
nest.SetStatus(rec,{'record_from': ['rate']})
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
nest.Connect(rec, tgts)
#! =================
#! Spike detector
#! =================
detectors = []
retina_failed_detectors = []
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc')]:
rec = nest.Create('spike_detector', params={"withgid": True, "withtime": True})
#rec = nest.Create('spike_detector')
detectors.append([rec,population,model])
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
if model == 'Retina':
for t in tgts:
try:
#nest.Connect(rec, [t])
nest.Connect([t], rec)
#print('connected %d' % t)
except:
print('%d did not work' % t)
retina_failed_detectors.append(t)
else:
nest.Connect(tgts, rec)
sg = [nd for nd in nest.GetLeaves(Retina_layer)[0] if nest.GetStatus([nd], 'model')[0] == 'Retina']
# ====================
# Set inputs
# ====================
retina_spikes = input_util.create_movie_input(Params)
num_files = retina_spikes.shape[0]
num_retina = retina_spikes.shape[1]
if num_retina != Params['Np']*Params['Np']:
print('num_retina should be equal as Np*Np')
for i in range(0, num_retina, 1):
src_firing_times = np.where(retina_spikes.transpose()[i])[0] + 1
firing_times = []
if len(src_firing_times) > 0:
for l in range(0, int(Params['intervals'] / num_files) + 1, 1):
offset = float(l*num_files)
tmp = src_firing_times + offset
firing_times = firing_times + tmp.astype(float).tolist()
nest.SetStatus([sg[i]], {'spike_times': firing_times})
else:
nest.SetStatus([sg[i]], {'spike_times': [1.0]})
'''
for l in range(0, int(Params['intervals'] / num_files) + 1, 1):
for i in range(0, num_retina, 1):
tmp_spk = nest.GetStatus([sg[i]])[0]['spike_times']
spk = tmp_spk.tolist()
spk.append( float(l*num_retina+(i+1)) )
nest.SetStatus([sg[i]],{'spike_times': spk})
'''
#! ====================
#! Initiation
#! ====================
#nest.Simulate(num_files)
nest.Simulate(500.0)
#! ====================
#! Simulation
#! ====================
nest.Simulate(Params['intervals'])
#! ====================
#! Save Results
#! ====================
print('save recorders data')
# Set folder
#rootdir = '/home/kfujii2/newNEST2/ht_model_pablo_based/data/'
#expdir = 'random/'
# expdir = 'random_full/'
# expdir = 'structured_full/'
# data_folder = rootdir + expdir
data_folder = Params['data_folder']
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
# To save spike data, set pairs of population id and its name
population_name = [ {'population': Retina_layer, 'name': 'Retina'},
{'population': Vp_vertical, 'name': 'Vp_v'},
{'population': Vp_horizontal, 'name': 'Vp_h'},
{'population': Rp_layer, 'name': 'Rp'},
{'population': Tp_layer, 'name': 'Tp'},
{'population': Vs_vertical, 'name': 'Vs_v'},
{'population': Vs_horizontal, 'name': 'Vs_h'}]
for rec, population, model in recorders:
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
data = nest.GetStatus(rec)[0]['events']
if model == 'Retina':
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'rate': data['rate']})
else:
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'V_m': data['V_m'],
'I_syn_AMPA': data['I_syn_AMPA'],
'I_syn_NMDA': data['I_syn_NMDA'],
'I_syn_GABA_A': data['I_syn_GABA_A'],
'I_syn_GABA_B': data['I_syn_GABA_B'],
'g_AMPA': data['g_AMPA'],
'g_NMDA': data['g_NMDA'],
'g_GABAA': data['g_GABAA'],
'g_GABAB': data['g_GABAB']} )
print('save raster images')
plt.close()
for rec, population, model in detectors:
spikes = nest.GetStatus(rec, 'events')[0]
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
if len(nest.GetStatus(rec)[0]['events']['senders']) > 3:
raster = raster_plot.from_device(rec, hist=True)
pylab.title( p_name + '_' + model )
f = raster[0].figure
f.set_size_inches(15, 9)
f.savefig(data_folder + 'spikes_' + p_name + '_' + model + '.png', dpi=100)
plt.close()
# Set filename and save spike data
filename = data_folder + 'spike_' + p_name + '_' + model + '.pickle'
pickle.dump(spikes, open(filename, 'w'))
scipy.io.savemat(data_folder + '/spike_' + p_name + '_' + model + '.mat', mdict={'senders': spikes['senders'], 'times': spikes['times']})
shutil.copy2('network_full_keiko.py', Params['data_folder'] + 'network_full_keiko.py')
shutil.copy2('figure_3_plot.py', Params['data_folder'] + 'figure_3_plot.py')
shutil.copy2('main.py', Params['data_folder'] + 'main.py')
#scipy.io.savemat(data_folder + '/retina_failed_detectors.mat', mdict={'detectors': retina_failed_detectors})
scipy.io.savemat(data_folder + '/retina_spike_times.mat', mdict={'spike_times': retina_spikes})
print('end')
def simulation(Params):
#! =================
#! Import network
#! =================
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({
"local_num_threads": Params['threads'],
'resolution': Params['resolution']
})
nest.SetStatus([0], {'print_time': True})
# import network description
# import network
# reload(network)
# models, layers, conns = network.get_Network(Params)
import network_full_keiko
reload(network_full_keiko)
models, layers, conns = network_full_keiko.get_Network(Params)
# Create models
for m in models:
nest.CopyModel(m[0], m[1], m[2])
# Create layers, store layer info in Python variable
for l in layers:
exec '%s = tp.CreateLayer(l[1])' % l[0]
# Create connections, need to insert variable names
for c in conns:
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
# --------------------------------------------------------------------#
# ---------- SET IB NEURONS ----------------------------------------- #
# --------------------------------------------------------------------#
# 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron.
# That is achieved by setting pacemaker current I_h.
# So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0.
# (Other cortical neuron do not have I_h, thus h_g_peak=0.0)
L56_vertical_idx = [
nd for nd in nest.GetLeaves(Vp_vertical)[0]
if nest.GetStatus([nd], 'model')[0] == 'L56_exc'
]
L56_horizontal_idx = [
nd for nd in nest.GetLeaves(Vp_horizontal)[0]
if nest.GetStatus([nd], 'model')[0] == 'L56_exc'
]
num_neuron = len(L56_vertical_idx)
num_ib = int(num_neuron * 0.3)
ridx_vertical = np.random.randint(num_neuron, size=(1, num_ib))[0]
ridx_horizontal = np.random.randint(num_neuron, size=(1, num_ib))[0]
for i in range(1, num_ib, 1):
nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'h_g_peak': 1.0})
nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]],
{'h_g_peak': 1.0})
# initiate network activity
nest.Simulate(500.0)
#nest.Simulate(100.0)
#! =================
#! Recording devices
#! =================
nest.CopyModel('multimeter',
'RecordingNode',
params={
'interval':
Params['resolution'],
'record_from': [
'V_m', 'I_syn_AMPA', 'I_syn_NMDA', 'I_syn_GABA_A',
'I_syn_GABA_B', 'g_AMPA', 'g_NMDA', 'g_GABAA',
'g_GABAB', 'I_h', 'I_NaP', 'I_KNa'
],
'record_to': ['memory'],
'withgid':
True,
'withtime':
False
})
recorders = []
nest.CopyModel('multimeter',
'RecordingNodeIntrinsic',
params={
'interval':
Params['resolution'],
'record_from': [
'V_m', 'I_syn_AMPA', 'I_syn_NMDA', 'I_syn_GABA_A',
'I_syn_GABA_B', 'g_AMPA', 'g_NMDA', 'g_GABAA',
'g_GABAB', 'I_h', 'I_NaP', 'I_KNa'
],
'record_to': ['memory'],
'withgid':
True,
'withtime':
True
})
recorders2 = []
for population, model in [(Retina_layer, 'Retina'), (Tp_layer, 'Tp_exc'),
(Rp_layer, 'Rp'), (Vp_vertical, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_vertical, 'L56_exc')]:
rec = nest.Create('RecordingNode')
recorders.append([rec, population, model])
if (model == 'Retina'):
nest.SetStatus(rec, {'record_from': ['rate']})
tgts = [
nd for nd in nest.GetLeaves(population)[0]
if nest.GetStatus([nd], 'model')[0] == model
]
nest.Connect(rec, tgts)
for population, model in [(Vp_vertical, 'L23_exc')]:
rec = nest.Create('RecordingNodeIntrinsic')
recorders2.append([rec, population, model])
tgts = [
nd for nd in nest.GetLeaves(population)[0]
if nest.GetStatus([nd], 'model')[0] == model
]
nest.Connect(rec, tgts)
#! =================
#! Spike detector
#! =================
detectors = []
for population, model in [
(Retina_layer, 'Retina'), (Tp_layer, 'Tp_exc'), (Tp_layer, 'Tp_inh'),
(Rp_layer, 'Rp'), (Vp_vertical, 'L23_exc'), (Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'), (Vp_horizontal, 'L23_inh'),
(Vp_vertical, 'L4_exc'), (Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'), (Vp_horizontal, 'L4_inh'),
(Vp_vertical, 'L56_exc'), (Vp_horizontal, 'L56_exc'),
(Vp_vertical, 'L56_inh'), (Vp_horizontal, 'L56_inh')
]:
rec = nest.Create('spike_detector',
params={
"withgid": True,
"withtime": True
})
#rec = nest.Create('spike_detector')
detectors.append([rec, population, model])
tgts = [
nd for nd in nest.GetLeaves(population)[0]
if nest.GetStatus([nd], 'model')[0] == model
]
if model == 'Retina':
for t in tgts:
try:
nest.Connect([t], rec)
print('connected %d' % t)
except:
print('%d did not work' % t)
else:
nest.Connect(tgts, rec)
#! ====================
#! Simulation
#! ====================
nest.SetStatus([0], {'print_time': True})
t_sim = 0
for t in Params['intervals']:
if (t_sim == 0):
gKL = 1.0
NaP_g_peak = 0.5
h_g_peak = 1.0
T_g_peak = 1.0
KNa_g_peak = 0.5
I_syn_AMPA_gain = 1.0 # keiko added this parameter in ht_neuron.cpp
print(t_sim)
'''
# Nov23 comment-out
if (t_sim==1):
gKL = 1.0 + 0.8/2.0
NaP_g_peak = 0.5 + 0.75/2.0
h_g_peak = 1.0 + 1.0/2.0
T_g_peak = 1.0 + 0.25/2.0
KNa_g_peak = 0.5 + 0.75/2.0
I_syn_AMPA_gain = 1.0 + 0.5/2.0 # keiko added this parameter in ht_neuron.cpp
#I_syn_AMPA_gain = 1.0 + 0.25/2.0 # keiko added this parameter in ht_neuron.cpp
print(t_sim)
'''
if (t_sim == 1):
gKL = 1.0 + 0.8 * (1.0 / 4.0)
NaP_g_peak = 0.5 + 0.75 * (1.0 / 4.0)
h_g_peak = 1.0 + 1.0 * (1.0 / 4.0)
T_g_peak = 1.0 + 0.25 * (1.0 / 4.0)
KNa_g_peak = 0.5 + 0.75 * (1.0 / 4.0)
I_syn_AMPA_gain = 1.0 + 0.25 * (
1.0 / 4.0) # keiko added this parameter in ht_neuron.cpp
#I_syn_AMPA_gain = 1.0 + 0.25/2.0 # keiko added this parameter in ht_neuron.cpp
print(t_sim)
if (t_sim == 2):
gKL = 1.0 + 0.8 * (2.0 / 4.0)
NaP_g_peak = 0.5 + 0.75 * (2.0 / 4.0)
h_g_peak = 1.0 + 1.0 * (2.0 / 4.0)
T_g_peak = 1.0 + 0.25 * (2.0 / 4.0)
KNa_g_peak = 0.5 + 0.75 * (2.0 / 4.0)
I_syn_AMPA_gain = 1.0 + 0.25 * (
2.0 / 4.0) # keiko added this parameter in ht_neuron.cpp
#I_syn_AMPA_gain = 1.0 + 0.25/2.0 # keiko added this parameter in ht_neuron.cpp
print(t_sim)
if (t_sim == 3):
gKL = 1.0 + 0.8 * (3.0 / 4.0)
NaP_g_peak = 0.5 + 0.75 * (3.0 / 4.0)
h_g_peak = 1.0 + 1.0 * (3.0 / 4.0)
T_g_peak = 1.0 + 0.25 * (3.0 / 4.0)
KNa_g_peak = 0.5 + 0.75 * (3.0 / 4.0)
I_syn_AMPA_gain = 1.0 + 0.25 * (
3.0 / 4.0) # keiko added this parameter in ht_neuron.cpp
#I_syn_AMPA_gain = 1.0 + 0.25/2.0 # keiko added this parameter in ht_neuron.cpp
print(t_sim)
if (t_sim == 4):
gKL = 1.0 + 0.8
NaP_g_peak = 0.5 + 0.75
h_g_peak = 1.0 + 1.0
T_g_peak = 1.0 + 0.25
KNa_g_peak = 0.5 + 0.75
I_syn_AMPA_gain = 1.0 + 0.25 # keiko added this parameter in ht_neuron.cpp
#I_syn_AMPA_gain = 1.0 + 0.25 # keiko added this parameter in ht_neuron.cpp
print(t_sim)
t_sim += 1
# change conductances in all populations
for l in layers:
sim_elements = l[1]['elements']
for m in np.arange(0, np.size(sim_elements), 1):
if (np.size(sim_elements) == 1):
sim_model = sim_elements
else:
sim_model = sim_elements[m]
exec("la = %s" % l[0])
pop = [
nd for nd in nest.GetLeaves(la)[0]
if nest.GetStatus([nd], 'model')[0] == sim_model
]
if (l[0] != 'Retina_layer'):
for cell in pop:
nest.SetStatus([cell], {'g_KL': gKL})
if (nest.GetStatus([cell], 'NaP_g_peak')[0]) > 0.0:
nest.SetStatus([cell], {'NaP_g_peak': NaP_g_peak})
if (nest.GetStatus([cell], 'h_g_peak')[0]) > 0.0:
nest.SetStatus([cell], {'h_g_peak': h_g_peak})
if (nest.GetStatus([cell], 'T_g_peak')[0]) > 0.0:
nest.SetStatus([cell], {'T_g_peak': T_g_peak})
if (nest.GetStatus([cell], 'KNa_g_peak')[0]) > 0.0:
nest.SetStatus([cell], {'KNa_g_peak': KNa_g_peak})
#if((nest.GetStatus([cell],'I_syn_AMPA_gain')[0])>0.0):
# nest.SetStatus([cell], {'I_syn_AMPA_gain': I_syn_AMPA_gain}) # keiko
if l[0].__contains__('Vp') or l[0].__contains__('Vs'):
#print('%s %s' %(l[0], sim_model))
for cell in pop:
nest.SetStatus(
[cell],
{'I_syn_AMPA_gain': I_syn_AMPA_gain}) # keiko
# simulate interval
nest.Simulate(t)
#! ====================
#! Plot Results
#! ====================
print "plotting..."
rows = 11
cols = 2
fig = plt.figure()
fig.subplots_adjust(hspace=0.4)
# Plot A: membrane potential rasters
recorded_models = [(Retina_layer, 'Retina'), (Vp_vertical, 'L23_exc'),
(Vp_vertical, 'L4_exc'), (Vp_vertical, 'L56_exc'),
(Rp_layer, 'Rp'), (Tp_layer, 'Tp_exc')]
plotting.potential_raster(fig, recorders, recorded_models, 100,
3 * Params['Np'], np.sum(Params['intervals']),
Params['resolution'], rows, cols, 0)
# Plot B: individual intracellular traces
recorded_models = [(Vp_vertical, 'L23_exc'), (Vp_vertical, 'L23_inh'),
(Rp_layer, 'Rp'), (Tp_layer, 'Tp_exc')]
# original
#plotting.intracellular_potentials(fig,recorders,recorded_models,100,rows,cols,6)
# keiko
total_time = 0.0
for t in Params['intervals']:
total_time += t
plotting.intracellular_potentials(fig, recorders, recorded_models, 100,
rows, cols, 6, total_time)
# Plot C: topographical activity of the up- and down-states
recorded_models = [(Vp_vertical, 'L23_exc')]
labels = ["Upstate"]
start = 2500.0
stop = 2510.0
#start = 900.0
#stop = 910.0
plotting.topographic_representation(fig, recorders, recorded_models,
labels, Params['Np'],
np.sum(Params['intervals']),
Params['resolution'], rows, cols,
start, stop, 10, 0)
labels = ["Downstate"]
start = 2600.0
stop = 2610.0
#start = 1550.0
#stop = 1560.0
plotting.topographic_representation(fig, recorders, recorded_models,
labels, Params['Np'],
np.sum(Params['intervals']),
Params['resolution'], rows, cols,
start, stop, 10, 1)
# Plot D: Intrinsic currents of a selected cell
recorded_models = [(Vp_vertical, 'L23_exc')]
plotting.intrinsic_currents(recorders2, recorded_models, 100)
plotting.synaptic_currents(recorders2, recorded_models, 100)
plt.show()
# Plot E: movie
#labels = ["Osc_Vp_L23_Vertical"]
#recorded_models = [(Vp_vertical,'L23_exc')]
#plotting.makeMovie(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'])
#! ====================
#! Save Results
#! ====================
print('save recorders data')
# Set folder
rootdir = '/home/kfujii2/newNEST2/ht_model_pablo_based/data/'
expdir = ''
# expdir = 'random_full/'
# expdir = 'structured_full/'
data_folder = rootdir + expdir
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
# To save spike data, set pairs of population id and its name
population_name = [{
'population': Retina_layer,
'name': 'Retina'
}, {
'population': Vp_vertical,
'name': 'Vp_v'
}, {
'population': Vp_horizontal,
'name': 'Vp_h'
}, {
'population': Rp_layer,
'name': 'Rp'
}, {
'population': Tp_layer,
'name': 'Tp'
}]
# vertical
population = population_name[1]['population']
name = population_name[1]['name']
model_list = ['L23_exc', 'L56_exc']
for model in model_list:
l = [
nd for nd in np.arange(0, len(recorders))
if (recorders[nd][1] == population and recorders[nd][2] == model)
][0]
data = nest.GetStatus(recorders[l][0], keys='events')[0]
scipy.io.savemat(data_folder + '/recorder_' + name + '_' + model +
'.mat',
mdict={
'senders': data['senders'],
'V_m': data['V_m'],
'I_syn_AMPA': data['I_syn_AMPA'],
'I_syn_NMDA': data['I_syn_NMDA'],
'I_syn_GABA_A': data['I_syn_GABA_A'],
'I_syn_GABA_B': data['I_syn_GABA_B'],
'g_AMPA': data['g_AMPA'],
'g_NMDA': data['g_NMDA'],
'g_GABAA': data['g_GABAA'],
'g_GABAB': data['g_GABAB']
})
print('save raster images')
plt.close()
for rec, population, model in detectors:
spikes = nest.GetStatus(rec, 'events')[0]
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
raster = raster_plot.from_device(rec, hist=True)
pylab.title(p_name + '_' + model)
f = raster[0].figure
f.set_size_inches(15, 9)
f.savefig(data_folder + 'spikes_' + p_name + '_' + model + '.png',
dpi=100)
plt.close()
'''
# Set filename and save spike data
filename = data_folder + 'spike_' + p_name + '_' + model + '.pickle'
pickle.dump(spikes, open(filename, 'w'))
filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat'
filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '.dat'
filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '.dat'
filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '.dat'
tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA)
tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA)
tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB)
'''
'''
def simulation(Params):
root_folder = Params['root_folder']
if not os.path.isdir(root_folder):
os.makedirs(root_folder)
net_folder = root_folder + Params['net_folder']
if not os.path.isdir(net_folder):
os.makedirs(net_folder)
conn_folder = net_folder + '/connections'
if not os.path.isdir(conn_folder):
os.makedirs(conn_folder)
data_folder = net_folder + Params['data_folder']
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
#! =================
#! Import network
#! =================
# NEST Kernel and Network settings
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({"local_num_threads": Params['threads'],'resolution': Params['resolution']})
nest.SetStatus([0],{'print_time': True})
# initialize random seed
import time
msd = int(round(time.time() * 1000))
nest.SetKernelStatus({'grng_seed' : msd})
nest.SetKernelStatus({'rng_seeds' : range(msd+Params['threads']+1, msd+2*Params['threads']+1)})
import importlib
network = importlib.import_module(Params['network'])
reload(network)
models, layers, conns = network.get_Network(Params)
# TODO this should come from network file
synapse_models = ['AMPA_syn', 'NMDA_syn', 'GABA_A_syn', 'GABA_B_syn', 'reticular_projection']
# synapse_models = ['AMPA_syn', 'NMDA_syn', 'GABA_A_syn', 'GABA_B_syn']
# Create models
print('Creating models...', end="")
for m in models:
print('.', end="")
# print(m), print('\n')
nest.CopyModel(m[0], m[1], m[2])
print(' done.')
# Create layers, store layer info in Python variable
print('Creating layers...', end="")
for l in layers:
print('.', end="")
exec '%s = tp.CreateLayer(l[1])' % l[0] in globals(), locals()
print(' done.')
# Create connections, need to insert variable names
print('Creating connections...', end="")
for c in conns:
print('.', end="")
eval('tp.ConnectLayers(%s,%s,c[2])' % (c[0], c[1]))
print(' done.')
# --------------------------------------------------------------------#
# ---------- SET IB NEURONS ----------------------------------------- #
# --------------------------------------------------------------------#
print('Set IB neurons')
# 30% of Cortex L56 excitatory neurons are intrinsically bursting(IB) neuron.
# That is achieved by setting pacemaker current I_h.
# So select 30% of L56_exc neuron, and change h_g_peak from 0.0 to 1.0.
# (Other cortical neuron do not have I_h, thus h_g_peak=0.0)
L56_vertical_idx = [nd for nd in nest.GetLeaves(Vp_vertical)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
L56_horizontal_idx = [nd for nd in nest.GetLeaves(Vp_horizontal)[0] if nest.GetStatus([nd], 'model')[0]=='L56_exc']
num_neuron = len(L56_vertical_idx)
num_ib = int(num_neuron*0.3)
ridx_vertical = np.random.randint(num_neuron, size=(1,num_ib))[0]
ridx_horizontal = np.random.randint(num_neuron, size=(1,num_ib))[0]
for i in range(1,num_ib,1):
nest.SetStatus([L56_vertical_idx[ridx_vertical[i]]], {'g_peak_h': 1.0})
nest.SetStatus([L56_horizontal_idx[ridx_horizontal[i]]], {'g_peak_h': 1.0})
# --------------------------------------------------------------------#
# ---------- SET RETINA STATIC FIRING RATE -------------------------- #
# --------------------------------------------------------------------#
print('Set Retina inputs neurons')
if not Params['new_image']: #Read
with open(Params['image_folder']+Params['image_name']+'.pickle', 'rb') as handle:
image_dic = pickle.load(handle)
else:
image_dic = static_input_utils.create_default_image(Params['new_image_elements'], Params['Np'])
if not Params['image_name']=='':
static_input_utils.save_new_image_dic(Params['image_folder'] + Params['image_name'], image_dic)
luminances = image_dic['luminances']
fig = plt.figure()
plt.imshow(luminances, interpolation='nearest')
fig.savefig(data_folder + '/input_image.png', dpi=100)
if not np.shape(luminances) == (Params['Np'], Params['Np']):
raise ValueError('Wrong definition for the input image %s' % (Params['image_folder']+Params['image_name']))
# For each 'pixel' (retina neuron) we set the rate of the poisson generator to maxrate * ret_rate + minrate
#if 'automatic_min_rate', minrate is determined so that mean retinal activity is mean_rate
#Iterate over indices of image.
if Params['automatic_min_rate']:
N_on = np.sum(luminances)
N_tot = (Params['Np'] ** 2)
minrate = (N_tot * Params['mean_rate'] - N_on * Params['ret_rate'] )/ ( N_tot - N_on)
else:
minrate = Params['ret_rate_baseline']
for i in range(Params['Np']):
for j in range(Params['Np']):
#Get node, set corresponding luminance
currnode = tp.GetElement(Retina_layer, (j, i))[0] #NB: Because of the inconsistency of the GetElement function we have to transpose.
if luminances[i,j] > 0.:
nest.SetStatus([currnode], {"rate": Params['ret_rate']})
else:
nest.SetStatus([currnode], {"rate": minrate})
# --------------------------------------------------------------------#
# ---------------------------- INITIATE ---------------------------- #
# --------------------------------------------------------------------#
print('Simulate %i secs' % Params['initiation_time'])
nest.Simulate(Params['initiation_time'])
#! =================
#! Recording devices
#! =================
print('Connecting recorders...', end="")
nest.CopyModel('multimeter', 'RecordingNode',
params = {'interval' : Params['resolution'],
'record_from': ['V_m'
# Put back when plotting synaptic currents, otherwise makes everything slower for no reason
# 'I_syn_AMPA',
# 'I_syn_NMDA',
# 'I_syn_GABA_A',
# 'I_syn_GABA_B',
#'g_AMPA',
#'g_NMDA',
#'g_GABAA',
#'g_GABAB',
#'I_NaP',
#'I_KNa',
#'I_T',
#'I_h'
],
'record_to' : ['memory'],
'withgid' : True,
'withtime' : True})
recorders = []
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Rp_layer , 'Rp'),
(Vp_vertical, 'L23_exc'),
(Vp_horizontal, 'L23_exc'),
(Vp_vertical, 'L23_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_vertical, 'L4_inh'),
(Vp_vertical, 'L56_exc'),
(Vp_horizontal, 'L56_exc'),
(Vs_vertical, 'L23_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_vertical, 'L4_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_vertical, 'L56_exc'),
(Vs_horizontal, 'L56_exc'),
(Vs_cross, 'L23_exc'),
(Vs_cross, 'L4_exc'),
(Vs_cross, 'L56_exc'),
]:
rec = nest.Create('RecordingNode')
recorders.append([rec,population,model])
if (model=='Retina'):
nest.SetStatus(rec,{'record_from': ['rate']})
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
nest.Connect(rec, tgts)
print('done.')
#! =================
#! Spike detector
#! =================
print('Connecting detectors...', end="")
detectors = []
retina_failed_detectors = []
for population, model in [(Retina_layer, 'Retina'),
(Tp_layer , 'Tp_exc'),
(Tp_layer , 'Tp_inh'),
(Vp_vertical, 'L4_exc'),
(Vp_horizontal, 'L4_exc'),
(Vs_cross, 'L4_exc')]:
rec = nest.Create('spike_detector', params={"withgid": True, "withtime": True})
#rec = nest.Create('spike_detector')
detectors.append([rec,population,model])
tgts = [nd for nd in nest.GetLeaves(population)[0] if nest.GetStatus([nd], 'model')[0]==model]
if model == 'Retina':
for t in tgts:
try:
# nest.Connect([t], rec, None, {'delay': recorders_delay})
nest.Connect([t], rec)
#print('connected %d' % t)
except:
print('%d did not work' % t)
retina_failed_detectors.append(t)
else:
nest.Connect(tgts, rec)
sg = [nd for nd in nest.GetLeaves(Retina_layer)[0] if nest.GetStatus([nd], 'model')[0] == 'Retina']
#! ====================
#! Simulation
#! ====================
# Simulate
for t in Params['intervals']:
# TODO: useless as is
# if Params['input_flag']==True:
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': Params['ret_rate']})
# else:
# nest.SetStatus(nest.GetLeaves(Retina_layer)[0], {'amplitude': 0.0})
nest.Simulate(t)
#! ====================
#! Plot Results
#! ====================
print("Creating figure 3...")
rows = 9
cols = 2
#Tom: We plot temporal data for the column to which the vertical line in the image is presented
#nest.GetLeaves() numbers the elements starting top left and descending vertically.
# Therefore starting_neuron (given to plotting.potential_rater) must be the index of the node in the first row.
# starting_neuron = 0 plots the first column, starting_neuron = 40 the second, etc
vertical_bar_column = image_dic['vertical'][1]
starting_neuron_Vp = Params['Np']*vertical_bar_column
fig = plt.figure(num=None, figsize=(13, 24), dpi=100)
fig.subplots_adjust(hspace=0.4)
# Plot A: membrane potential rasters
recorded_models = [(Retina_layer,'Retina'),
(Vp_vertical,'L23_exc'),
(Vp_vertical,'L4_exc'),
(Vp_vertical,'L56_exc'),
(Rp_layer,'Rp'),
(Tp_layer,'Tp_exc')]
#plotting.potential_raster(fig,recorders,recorded_models,0,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plotting.potential_raster(fig,recorders,recorded_models,starting_neuron_Vp,Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
rows,cols,0)
#starting_neuron = 800+1
#plotting.potential_raster(fig,recorders,recorded_models,starting_neuron,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,0)
plt.title('Evoked')
# Plot B: individual intracellular traces
recorded_models =[(Vp_vertical,'L4_exc'),
(Vp_vertical,'L4_inh')]
#plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6) #original
# keiko
total_time = 0.0
for t in Params['intervals']:
total_time += t
#draw_neuron = (Params['Np']*Params['Np']/2)
#plotting.intracellular_potentials(fig, recorders, recorded_models, draw_neuron, rows, cols, 6, total_time)
plotting.intracellular_potentials(fig, recorders, recorded_models, 21, rows, cols, 6, total_time)
#plotting.intracellular_potentials(fig, recorders, recorded_models, 820, rows, cols, 6, total_time)
# Plot C: topographical activity of the vertical and horizontal layers
if Params.has_key('start_membrane_potential') and Params.has_key('end_membrane_potential'):
start = Params['start_membrane_potential']
stop = Params['end_membrane_potential']
else:
start = 130.0
stop = 140.0
recorded_models = [(Vp_vertical,'L23_exc')]
labels = ["Vertical"]
plotting.topographic_representation(fig,
recorders,
recorded_models,
labels,
Params['Np'],
np.sum(Params['intervals']),
Params['resolution'],
rows,
cols,
start,
stop,
8,
0)
recorded_models = [(Vp_horizontal,'L23_exc')]
labels = ["Horizontal"]
plotting.topographic_representation(fig,recorders,recorded_models,labels,Params['Np'],np.sum(Params['intervals']),Params['resolution'],rows,cols,start,stop,8,1)
fig.savefig(data_folder + '/figure3.png', dpi=100)
if Params.has_key('show_main_figure') and Params['show_main_figure']:
plt.show()
# Plot C: topographical activity of all layers
if Params.has_key('plot_topo_all_regions') and Params['plot_topo_all_regions']:
if Params.has_key('start_membrane_potential') and Params.has_key('end_membrane_potential'):
start = Params['start_membrane_potential']
stop = Params['end_membrane_potential']
else:
start = 130.0
stop = 140.0
####### USER INPUT
# First column
vertical_models = [(Retina_layer, 'Retina'),
(Vp_vertical, 'L23_exc'),
(Vp_vertical, 'L4_exc'),
(Vp_vertical, 'L56_exc'),
(Vs_vertical, 'L23_exc'),
(Vs_vertical, 'L4_exc'),
(Vs_vertical, 'L56_exc')]
# Second column
horizontal_models = [(Retina_layer, 'Retina'),
(Vp_horizontal, 'L23_exc'),
(Vp_horizontal, 'L4_exc'),
(Vp_horizontal, 'L56_exc'),
(Vs_horizontal, 'L23_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_horizontal, 'L56_exc')]
# Third column
cross_models = [(Retina_layer, 'Retina'),
(),
(),
(),
(Vs_cross, 'L23_exc'),
(Vs_cross, 'L4_exc'),
(Vs_cross, 'L56_exc')]
# Column labels
labels = ['Vertical', 'Horizontal', 'Cross']
# Row labels
areas = ['Retina', 'Primary\nL2/3', 'Primary\nL4', 'Primary\nL5/6', 'Secondary\nL2/3', 'Secondary\nL4',
'Secondary\nL4/6']
# Number of neurons in each plotted layer:
Np, Ns = Params['Np'], Params['Ns']
n_neurons = [Np, Np, Np, Np, Ns, Ns, Ns]
recorded_models = [vertical_models, horizontal_models, cross_models]
######## end USER INPUT
fig = plotting.all_topographic(recorders, recorded_models, labels, areas,
n_neurons,
np.sum(Params['intervals']),
Params['resolution'], start, stop)
fig.savefig(data_folder + '/figure_all_topo.png', dpi=100)
if Params.has_key('show_main_figure') and Params['show_main_figure']:
plt.show()
# Plot F: All areas
if Params.has_key('plot_all_regions') and Params['plot_all_regions']:
print("Creating plot of all areas")
vertical_bar_column_Vp = image_dic['vertical'][1]
vertical_bar_column_Vs = vertical_bar_column_Vp * Params['Ns']/Params['Np']
starting_neuron_Vp = Params['Np'] * vertical_bar_column_Vp
starting_neuron_Vs = Params['Ns'] * vertical_bar_column_Vs
#### USER INPUT
vertical_models = [(Retina_layer,'Retina'),
(Vp_vertical,'L23_exc'),
(Vp_vertical,'L4_exc'),
(Vp_vertical,'L56_exc'),
(Vs_vertical,'L23_exc'),
(Vs_vertical, 'L4_exc'),
(Vs_vertical, 'L56_exc')]
horizontal_models = [(Retina_layer,'Retina'),
(Vp_horizontal,'L23_exc'),
(Vp_horizontal,'L4_exc'),
(Vp_horizontal,'L56_exc'),
(Vs_horizontal,'L23_exc'),
(Vs_horizontal, 'L4_exc'),
(Vs_horizontal, 'L56_exc')]
cross_models = [(Retina_layer,'Retina'),
(),
(),
(),
(Vs_cross,'L23_exc'),
(Vs_cross, 'L4_exc'),
(Vs_cross, 'L56_exc')]
labels = ['Vertical', 'Horizontal', 'Cross']
# Row labels
areas = ['Retina', 'Primary\nL2/3', 'Primary\nL4', 'Primary\nL5/6', 'Secondary\nL2/3', 'Secondary\nL4',
'Secondary\nL4/6']
#TODO: make this look nicer
# Number of neurons in each plotted layer:
Np, Ns = Params['Np'], Params['Ns']
n_neurons = [Np, Np, Np, Np, Ns, Ns, Ns]
# Starting neuron in each plotted layer:
starting_neurons = [starting_neuron_Vp, starting_neuron_Vp, starting_neuron_Vp, starting_neuron_Vp, starting_neuron_Vs, starting_neuron_Vs, starting_neuron_Vs]
plotcols = [vertical_models, horizontal_models, cross_models]
#### end USER INPUT
fig = plotting.potential_raster_multiple_models(fig, recorders, plotcols, labels, areas, starting_neurons, n_neurons,
np.sum(Params['intervals']),
Params['resolution'],
0)
fig.savefig(data_folder + '/figure_all_areas.png', dpi=100)
#! ====================
#! Save Results
#! ====================
print('save recorders data')
# Set folder
#rootdir = '/home/kfujii2/newNEST2/ht_model_pablo_based/data/'
#expdir = 'random/'
# expdir = 'random_full/'
# expdir = 'structured_full/'
# data_folder = rootdir + expdir
# To save spike data, set pairs of population id and its name
population_name = [ {'population': Retina_layer, 'name': 'Retina'},
{'population': Vp_vertical, 'name': 'Vp_v'},
{'population': Vp_horizontal, 'name': 'Vp_h'},
{'population': Rp_layer, 'name': 'Rp'},
{'population': Tp_layer, 'name': 'Tp'},
{'population': Vs_vertical, 'name': 'Vs_v'},
{'population': Vs_horizontal, 'name': 'Vs_h'},
{'population': Vs_cross, 'name': 'Vs_c'}]
if Params.has_key('save_recorders') and Params['save_recorders']:
for rec, population, model in recorders:
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
data = nest.GetStatus(rec)[0]['events']
if model == 'Retina':
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'rate': data['rate']})
else:
scipy.io.savemat(data_folder + '/recorder_' + p_name + '_' + model + '.mat',
mdict={'senders': data['senders'],
'times': data['times'],
'V_m': data['V_m']
#'I_syn_AMPA': data['I_syn_AMPA'],
#'I_syn_NMDA': data['I_syn_NMDA'],
#'I_syn_GABA_A': data['I_syn_GABA_A'],
#'I_syn_GABA_B': data['I_syn_GABA_B'],
# 'g_AMPA': data['g_AMPA'],
# 'g_NMDA': data['g_NMDA'],
# 'g_GABA_A': data['g_GABA_A'],
# 'g_GABA_B': data['g_GABA_B']
} )
print('save raster images')
plt.close()
for rec, population, model in detectors:
spikes = nest.GetStatus(rec, 'events')[0]
# Get name of population
for p in range(0, len(population_name), 1):
if population_name[p]['population'] == population:
p_name = population_name[p]['name']
if len(nest.GetStatus(rec)[0]['events']['senders']) > 3:
raster = raster_plot.from_device(rec, hist=True)
pylab.title( p_name + '_' + model )
f = raster[0].figure
f.set_size_inches(15, 9)
f.savefig(data_folder + '/spikes_' + p_name + '_' + model + '.png', dpi=100)
plt.close()
# Set filename and save spike data
filename = data_folder + '/spike_' + p_name + '_' + model + '.pickle'
pickle.dump(spikes, open(filename, 'w'))
scipy.io.savemat(data_folder + '/spike_' + p_name + '_' + model + '.mat', mdict={'senders': spikes['senders'], 'times': spikes['times']})
'''
filename_AMPA = data_folder + 'connection_' + p_name + '_AMPA_syn' + '.dat'
filename_NMDA = data_folder + 'connection_' + p_name + '_NMDA_syn' + '.dat'
filename_GABAA = data_folder + 'connection_' + p_name + '_GABA_A_syn' + '.dat'
filename_GABAB = data_folder + 'connection_' + p_name + '_GABA_B_syn' + '.dat'
tp.DumpLayerConnections(population, 'AMPA_syn', filename_AMPA)
tp.DumpLayerConnections(population, 'NMDA_syn', filename_NMDA)
tp.DumpLayerConnections(population, 'GABA_A_syn', filename_GABAA)
tp.DumpLayerConnections(population, 'GABA_B_syn', filename_GABAB)
'''
'''
for p in range(0, len(population_name), 1):
population = population_name[p]['population']
p_name = population_name[p]['name']
filename_nodes = data_folder + '/gid_' + p_name + '.dat'
tp.DumpLayerNodes(population, filename_nodes)
'''
network_script = Params['network'] + '.py'
shutil.copy2(network_script, data_folder + '/' + network_script)
shutil.copy2(network_script, conn_folder + '/' + network_script)
print('end')
def create_network(self):
#! =============================
#! Configuration of the network
#! =============================
# Load the LIF neuron model
model = nest.Models(mtype='nodes',sel='iaf_bw_2003')
if not model:
nest.Install("mymodule")
# Layers are configured as free layers (no spatial structure)
pos_exc = [[np.random.uniform(-self.extent/2.0,self.extent/2.0),
np.random.uniform(-self.extent/2.0,self.extent/2.0)]
for j in range(self.N_exc)]
layerProps_exc = {
'positions': pos_exc,
'extent' : [self.extent, self.extent],
'edge_wrap': False
}
pos_inh = [[np.random.uniform(-self.extent/2.0,self.extent/2.0),
np.random.uniform(-self.extent/2.0,self.extent/2.0)]
for j in range(self.N_inh)]
layerProps_inh = {
'positions': pos_inh,
'extent' : [self.extent, self.extent],
'edge_wrap': False
}
# Layers of thalamocortical and cortical-cortical inputs have a single
# poisson generator that sends independent spike trains to each cell,
# instead of a layer with multiple poisson generators (to decrease
# memory consumption)
pos_th = [[np.random.uniform(-self.extent/2.0,self.extent/2.0),
np.random.uniform(-self.extent/2.0,self.extent/2.0)]
for j in range(1)]
layerProps_th = {
'positions': pos_th,
'extent' : [self.extent, self.extent],
'edge_wrap': False
}
pos_cc = [[np.random.uniform(-self.extent/2.0,self.extent/2.0),
np.random.uniform(-self.extent/2.0,self.extent/2.0)]
for j in range(1)]
layerProps_cc = {
'positions': pos_cc,
'extent' : [self.extent, self.extent],
'edge_wrap': False
}
# There is one parrot neuron for each excitatory/inhibitory cell of the network
pos_parrot = [[np.random.uniform(-self.extent/2.0,self.extent/2.0),
np.random.uniform(-self.extent/2.0,self.extent/2.0)]
for j in range(self.N_exc + self.N_inh)]
layerProps_parrot = {
'positions': pos_parrot,
'extent' : [self.extent, self.extent],
'edge_wrap': False
}
# NEST Kernel and Network settings
np.random.seed(int(time.time()))
seeds = np.arange(self.num_threads) + int((time.time()*100)%2**32) # Seeds
# are different in each simulation
nest.ResetKernel()
nest.ResetNetwork()
nest.SetKernelStatus({"local_num_threads": self.num_threads,
"resolution": self.simstep,
"data_path": os.path.abspath(os.path.join(__file__ ,"../results")),
"rng_seeds": list(seeds)})
# Define properties of neuron models
nest.CopyModel("iaf_bw_2003", "exc_cell", self.excitatory_cell_params)
nest.CopyModel("iaf_bw_2003", "inh_cell", self.inhibitory_cell_params)
# Thalamocortical and cortical-cortical inputs are defined as poisson generators
nest.CopyModel("inhomogeneous_poisson_generator", "thalamocortical_input")
nest.CopyModel("inhomogeneous_poisson_generator", "cortical_input")
# Create layers
self.exc = tp.CreateLayer(tools.updateDicts(layerProps_exc, {'elements': 'exc_cell'}))
self.inh = tp.CreateLayer(tools.updateDicts(layerProps_inh, {'elements': 'inh_cell'}))
self.thalamo = tp.CreateLayer(tools.updateDicts(layerProps_th,
{'elements': 'thalamocortical_input'}))
self.cort = tp.CreateLayer(tools.updateDicts(layerProps_cc,
{'elements': 'cortical_input'}))
# The layers of parrot neurons are used to compute the PSP (see below).
# They also facilitate the computation of spike times from external inputs
self.parrot_layer_th = tp.CreateLayer(tools.updateDicts(layerProps_parrot,
{'elements': 'parrot_neuron'}))
self.parrot_layer_cc = tp.CreateLayer(tools.updateDicts(layerProps_parrot,
{'elements': 'parrot_neuron'}))
# Ornstein-Uhlenbeck process (solved by Euler method)
time_array = np.arange(self.simstep,self.simtime-
self.simstep,self.simstep)
OU_n = len(time_array) # Number of time steps.
# Define renormalized variables (to avoid recomputing these constants
# at every time step)
OU_sigma_bis = self.OU_sigma * np.sqrt(2. / self.OU_tau)
OU_sqrtdt = np.sqrt(self.simstep)
OU_x = np.zeros(OU_n) # OU output
for i in range(OU_n - 1):
OU_x[i + 1] = OU_x[i] + self.simstep * (-OU_x[i] / self.OU_tau) + \
OU_sigma_bis * OU_sqrtdt * np.random.randn()
# Sinusoidal rate
v_signal = self.A_ext * np.sin(2.0 * np.pi * self.f_ext *
time_array/1000.0) + self.v_0
# Final rate of the Poisson generators
for n in nest.GetLeaves(self.thalamo)[0]:
nest.SetStatus([n],{'rate_times' : time_array,
'rate_values':v_signal})
for n in nest.GetLeaves(self.cort)[0]:
nest.SetStatus([n],{'rate_times' : time_array,
'rate_values':OU_x})
# Recurrent connections
# (the size of the mask is big enough to ensure all cells are included within it)
dict_exc_exc_recurrent = {
"connection_type":"convergent",
"mask": {'rectangular': {'lower_left':[-self.extent,-self.extent],
'upper_right':[self.extent,self.extent]}},
"kernel": self.P,
"synapse_model": 'static_synapse',
"weights": self.exc_exc_recurrent,
"sources": {"model": 'exc_cell'},
"targets": {"model": 'exc_cell'},
"allow_autapses":False,
"allow_multapses":False
}
dict_exc_inh_recurrent = {
"connection_type":"convergent",
"mask": {'rectangular': {'lower_left':[-self.extent,-self.extent],
'upper_right':[self.extent,self.extent]}},
"kernel": self.P,
"synapse_model": 'static_synapse',
"weights": self.exc_inh_recurrent,
"sources": {"model": 'exc_cell'},
"targets": {"model": 'inh_cell'},
"allow_autapses":False,
"allow_multapses":False
}
dict_inh_inh_recurrent = {
"connection_type":"convergent",
"mask": {'rectangular': {'lower_left':[-self.extent,-self.extent],
'upper_right':[self.extent,self.extent]}},
"kernel": self.P,
"synapse_model": 'static_synapse',
"weights": self.inh_inh_recurrent,
"sources": {"model": 'inh_cell'},
"targets": {"model": 'inh_cell'},
"allow_autapses":False,
"allow_multapses":False
}
dict_inh_exc_recurrent = {
"connection_type":"convergent",
"mask": {'rectangular': {'lower_left':[-self.extent,-self.extent],
'upper_right':[self.extent,self.extent]}},
"kernel": self.P,
"synapse_model": 'static_synapse',
"weights": self.inh_exc_recurrent,
"sources": {"model": 'inh_cell'},
"targets": {"model": 'exc_cell'},
"allow_autapses":False,
"allow_multapses":False
}
tp.ConnectLayers(self.exc,self.exc,dict_exc_exc_recurrent)
tp.ConnectLayers(self.exc,self.inh,dict_exc_inh_recurrent)
tp.ConnectLayers(self.inh,self.inh,dict_inh_inh_recurrent)
tp.ConnectLayers(self.inh,self.exc,dict_inh_exc_recurrent)
# Connections of the external inputs: each cell receives the same number of
# external inputs as recurrent excitatory inputs (800 for the 5000-neuron network)
dict_th_parrot = {
"connection_type":"convergent",
"mask": {'rectangular': {'lower_left':[-self.extent,-self.extent],
'upper_right':[self.extent,self.extent]}},
"kernel": 1.,
"synapse_model": 'static_synapse',
"number_of_connections": 800, # constant fan in
"weights": 1.0,
"sources": {"model": 'thalamocortical_input'},
"targets": {"model": 'parrot_neuron'},
"allow_autapses":False,
"allow_multapses":True
}
dict_cc_parrot = {
"connection_type":"convergent",
"mask": {'rectangular': {'lower_left':[-self.extent,-self.extent],
'upper_right':[self.extent,self.extent]}},
"kernel": 1.,
"synapse_model": 'static_synapse',
"number_of_connections": 800, # constant fan in
"weights": 1.0,
"sources": {"model": 'cortical_input'},
"targets": {"model": 'parrot_neuron'},
"allow_autapses":False,
"allow_multapses":True
}
# A parrot neuron is necessary to send the same spike train to both
# original cells and cloned cells (used to compute the PSP).
# Connection of Poisson generators with parrot neurons
tp.ConnectLayers(self.thalamo,self.parrot_layer_th,dict_th_parrot)
tp.ConnectLayers(self.cort,self.parrot_layer_cc,dict_cc_parrot)
parrot_n_th = nest.GetLeaves(self.parrot_layer_th)[0]
parrot_n_cc = nest.GetLeaves(self.parrot_layer_cc)[0]
# Connection of parrot neurons with excitatory/inhibitory neurons
i = 0
for n in nest.GetLeaves(self.exc)[0]:
nest.Connect([parrot_n_th[i]],[n],
'one_to_one',syn_spec={"model":"static_synapse",
"weight":self.th_exc_external})
nest.Connect([parrot_n_cc[i]],[n],
'one_to_one',syn_spec={"model":"static_synapse",
"weight":self.cc_exc_external})
i+=1
for n in nest.GetLeaves(self.inh)[0]:
nest.Connect([parrot_n_th[i]],[n],
'one_to_one',syn_spec={"model":"static_synapse",
"weight":self.th_inh_external})
nest.Connect([parrot_n_cc[i]],[n],
'one_to_one',syn_spec={"model":"static_synapse",
"weight":self.cc_inh_external})
i+=1
#! =================
#! Checkpoint
#! =================
# # Plot mask and kernel of connections
# fig = tp.PlotLayer(self.exc,nodesize =80)
# ctr = tp.FindCenterElement(self.exc)
#
# tp.PlotTargets(ctr, self.exc, fig = fig,
# mask=dict_exc_exc_recurrent['mask'], kernel=dict_exc_exc_recurrent['kernel'] ,
# src_size =250 , tgt_color = 'red' , tgt_size =20 ,
# kernel_color = 'green' )
#
# plt.show()
# # Print the avg. number of input connections
# pop_ex = nest.GetLeaves(self.exc)[0]
# pop_in = nest.GetLeaves(self.inh)[0]
# pop_parrot_th = nest.GetLeaves(self.parrot_layer_th)[0]
# pop_parrot_cc = nest.GetLeaves(self.parrot_layer_cc)[0]
# pop_thalamo = nest.GetLeaves(self.thalamo)[0]
# pop_cc = nest.GetLeaves(self.cort)[0]
#
# number_of_connections = [0,0,0,0]
# for k in range(100):
# conns_ex = nest.GetConnections(target = [pop_ex[k]])
# conns_th = nest.GetConnections(target = [pop_parrot_th[k]])
# conns_cc = nest.GetConnections(target = [pop_parrot_cc[k]])
#
# st_ex = nest.GetStatus(conns_ex)
# st_th = nest.GetStatus(conns_th)
# st_cc = nest.GetStatus(conns_cc)
#
# for st_con in st_ex:
# if st_con["source"] >= pop_ex[0] and st_con["source"] <= pop_ex[-1]:
# number_of_connections[0]+=1
# if st_con["source"] >= pop_in[0] and st_con["source"] <= pop_in[-1]:
# number_of_connections[1]+=1
#
# for st_con in st_th:
# if st_con["source"] >= pop_thalamo[0] and st_con["source"] <= pop_thalamo[-1]:
# number_of_connections[2]+=1
#
# for st_con in st_cc:
# if st_con["source"] >= pop_cc[0] and st_con["source"] <= pop_cc[-1]:
# number_of_connections[3]+=1
#
# print("\nExc: %s, Inh: %s, Thalamo: %s, Cort: %s\n" % (number_of_connections[0]/\
# 100.,number_of_connections[1]/100.,number_of_connections[2]/100.,
# number_of_connections[3]/100.))
#! =================================================
#! Computation of the average postsynaptic potential
#! =================================================
# Make a copy of a subset of neurons that receive same the synaptic input of
# the original ones. The cloned neurons receive an extra spike, from the synapse under
# investigation, each 100 ms
if self.Compute_PSP:
spike_gen_cloned = nest.Create("spike_generator")
nest.SetStatus(spike_gen_cloned,{"spike_times":np.arange(500.0,self.simtime,100.0)})
cloned_n_AMPA = nest.Create("exc_cell",self.PSP_number_cells)
cloned_n_GABA = nest.Create("exc_cell",self.PSP_number_cells)
j=0
for n in nest.GetLeaves(self.exc)[0]:
if j < self.PSP_number_cells:
conns = nest.GetConnections(target = [n])
st = nest.GetStatus(conns)
for st_con in st:
conn_dict = {'rule': 'one_to_one'}
syn_dict = {'weight': st_con["weight"]}
nest.Connect([st_con["source"]],[cloned_n_AMPA[j]],
conn_dict, syn_dict)
nest.Connect([st_con["source"]],[cloned_n_GABA[j]],
conn_dict, syn_dict)
# extra spike
nest.Connect(spike_gen_cloned,[cloned_n_AMPA[j]],conn_dict,
{'weight': self.exc_exc_recurrent})
nest.Connect(spike_gen_cloned,[cloned_n_GABA[j]],conn_dict,
{'weight': self.inh_exc_recurrent})
j+=1
#! =================
#! Recording devices
#! =================
# Membrane potential and conductances
if self.toMemory:
record_to = 'memory'
else:
record_to = 'file'
if len(self.To_be_measured)>0:
nest.CopyModel('multimeter', 'RecordingNode',
{'interval' : self.simstep,
'record_from': self.To_be_measured,
'record_to' : [record_to],
'withgid' : True,
'withtime' : True})
# Spikes
nest.CopyModel('spike_detector', 'SpikesRecorder',
{'record_to' : [record_to],
'withgid' : True,
'withtime' : True})
def reset():
import nest
nest.ResetNetwork()
