def test_freq():
from nest import SetKernelStatus, Simulate, ResetKernel, raster_plot
ResetKernel()
SetKernelStatus({
'total_num_virtual_procs': 2,
'print_time': True,
'resolution': 0.1})
paf = ProkhazkaAfferentFiber()
sd = Create('spike_detector', params={'withgid': True, 'withtime': True})
mm = Create('')
print(sd)
Connect(paf.neurons, sd)
Simulate(1000.)
raster_plot.from_device(sd, hist=True)
raster_plot.show()
def plot(self):
pylab.ion()
for i, sei in enumerate(self.se_integrator):
pylab.figure()
pylab.subplot(1, 2, 1)
pylab.title('Ca')
pylab.plot(self.sim_steps, self.ca_nest[0, :])
pylab.plot(self.sim_steps, self.ca_python[i])
pylab.legend(('nest', sei.__class__.__name__))
pylab.subplot(1, 2, 2)
pylab.title('Synaptic Element')
pylab.plot(self.sim_steps, self.se_nest[0, :])
pylab.plot(self.sim_steps, self.se_python[i])
pylab.legend(('nest', sei.__class__.__name__))
pylab.savefig('sp' + sei.__class__.__name__ + '.png')
raster_plot.from_device(self.spike_detector)
pylab.savefig('sp_raster_plot.png')
def plot(self):
pylab.ion()
for i, sei in enumerate(self.se_integrator):
pylab.figure()
pylab.subplot(1, 2, 1)
pylab.title('Ca')
pylab.plot(self.sim_steps, self.ca_nest[0, :])
pylab.plot(self.sim_steps, self.ca_python[i])
pylab.legend(('nest', sei.__class__.__name__))
pylab.subplot(1, 2, 2)
pylab.title('Synaptic Element')
pylab.plot(self.sim_steps, self.se_nest[0, :])
pylab.plot(self.sim_steps, self.se_python[i])
pylab.legend(('nest', sei.__class__.__name__))
pylab.savefig('sp' + sei.__class__.__name__ + '.png')
raster_plot.from_device(self.spike_detector)
pylab.savefig('sp_raster_plot.png')
def get_nest_raster(self):
"""Return the nest_raster plot and possibly error message."""
import nest
from nest import raster_plot
assert self.type == 'spike_detector'
raster, error_msg = None, None
if 'memory' not in self._record_to:
error_msg = 'Data was not saved to memory.'
elif not len(nest.GetStatus(self.gid)[0]['events']['senders']): # pylint: disable=len-as-condition
error_msg = 'No events were recorded.'
elif len(nest.GetStatus(self.gid)[0]['events']['senders']) == 1:
error_msg = 'There was only one sender'
else:
try:
raster = raster_plot.from_device(self.gid, hist=True)
except Exception as exception: # pylint: disable=broad-except
error_msg = (
f'Uncaught exception when generating raster.\n'
f'--> Exception message: {exception}\n'
f'--> Recorder status: {nest.GetStatus(self.gid)}')
return raster, error_msg
smf.write("avg seconds spent per nest.Simulate()"\
" simulation " + str(avg) + "\n")
if (myP):
print("avg seconds spent per nest.Simulate()"\
" simulation " + str(avg))
##print("sum " + str(sum))
# get multimeter recordings
events = nest.GetStatus(mm)[0]["events"]
#t = events["times"]
### for plotting
if (myPl):
# spike raster plot
raster_plot.from_device(sd)
# multiply by 10 for actual length of time (1sim/10ms)
pylab.xlim(0, len(optLengths) * 10)
raster_plot.show()
# 1 plot
pylab.clf()
pylab.subplot(211)
pylab.plot(events["times"], events["primary_rate"])
pylab.plot(events["times"], events["secondary_rate"])
#pylab.axis([0, len(optLengths)*10, -200, 200])
# change y bounds z
pylab.xlabel("time (ms)")
pylab.ylabel("membrane potential (mV) (with electrode "\
"inaccuracy,interfence ? )")
pylab.legend(("primary_rate", "secondary_rate"))
def createNestNetwork(individu,nbClusters, connectInter, connectIntra, pcExc, pcInh, nbNeuronByCluster, interRatio, plotMe=False):
TIME_SIM=400.0
ResetKernel()
print 'Initialisation du reseau'
nbNeurones = nbClusters * nbNeuronByCluster
neurones=Create("iaf_psc_delta",nbNeurones)
SetDefaults("spike_detector", {"withtime":True,"withgid":True})
spikedetector=Create("spike_detector")
correlator=Create("correlation_detector",params={"delta_tau":1.0,"tau_max":100.0})
print "Creation d'un individu"
#individu=Ind(nbClusters, connectInter, connectIntra, pcExc, pcInh, nbNeuronByCluster, interRatio)
print 'Connexion du reseau de neurones'
CopyModel("static_synapse","N2N")
#CopyModel("stdp_pl_synapse_hom","N2N")
for nSource,voisins in individu.graph.adjacency_iter():
#print nSource, voisins
for voisin,eattr in voisins.iteritems():
#print voisin, eattr
poids=eattr[0]['weight']
poids=poids*20
Connect([neurones[nSource]],[neurones[voisin]],params={"weight":double(poids)},model="N2N")
DRIVE=30
space= 0.9
NB_DRIVER = 20
#aleatime=random.randint(1,100)
t=0.1
times=[t+space*x for x in range(DRIVE)]
#times.extend([DRIVE + t+space*2*x+aleatime for x in range(DRIVE)])
spiker=Create("spike_generator",3,params={"spike_times":times})
DivergentConnect(spiker,neurones[1:NB_DRIVER])
ConvergentConnect(neurones,spikedetector)
Connect([neurones[3]],correlator,params={"receptor_type":0})
Connect([neurones[3]],correlator,params={"receptor_type":1})
SetStatus(spikedetector,[{"n_events":0}])
SetStatus(correlator,[{"n_events":[0,0]}])
noisy=Create("noise_generator", params={"mean":0.0, "std":10.0})
DivergentConnect(noisy, neurones)
print "Simulation en cours..."
Simulate(TIME_SIM)
rate=GetStatus(spikedetector,"n_events")[0]
print "Nombre de PAs : "******"Frequence moyenne : ",rate
#print "Nombre total de synapses : ", GetStatus("N2N","num_connections")
if (plotMe):
raster.from_device(spikedetector, "Petit raster artificiel", hist=True)
plt.figure()
plt.plot(GetStatus(correlator,"histogram")[0])
plt.show()
rasterDict=GetStatus(spikedetector,"events")[0]
return(rasterDict)
plt.plot(xaxis, LFP)
plt.ylabel('LFP')
plt.xlabel('s')
plt.axis([0.2,10.25, -10, 2])
plt.title('LFP in mosaic model')
## save the LFP as a .dat file
file = open('lfp.dat', 'wb')
file.write(LFP)
file.close()
import nest.raster_plot as raster
import nest.voltage_trace as vtrace
for popName, SD in spikeDetectors.items():
try:
raster.from_device(SD)
fig = pylab.gcf()
fig.suptitle(popName)
except:
continue
## find average firing rate up and down states
dt = 20.
simtime = 10000.
bins = np.arange(200., simtime, dt)
ratedict = dict()
for popName, SD in spikeDetectors.items():
if popName in ['TC', 'RE', 'INmin', 'PYmin']:
pass
else:
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})
# 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')
[e for e in nest.GetStatus([sd_actions[i]], keys="events")[0]["times"] if e > last_action_time]
) # calc the "firerate" of each actor population
if rate > max_rate:
max_rate = rate # the population with the hightes rate wins
chosen_action = i
possible_actions = env.actionsAvailable
FIRE_RATE_K = 0.5
new_position, outcome, in_end_position = env.move(possible_actions[chosen_action], max_rate * FIRE_RATE_K)
nest.SetStatus([sensors["right"]], {"rate": 0.0})
nest.SetStatus([sensors["left"]], {"rate": 0.0})
nest.SetStatus(noise, {"rate": 0.0})
for t in range(5):
nest.Simulate(4)
time.sleep(0.01)
last_action_time += 60
actions_executed += 1
else:
state = env.getState().copy()
nest.SetStatus([sensors["right"]], {"rate": 0.0})
nest.SetStatus([sensors["left"]], {"rate": 0.0})
nest.SetStatus(noise, {"rate": 0.0})
_, in_end_position = env.init_new_trial()
rplt.from_device(sd_all_actions, title="Actions")
rplt.from_device(sd_all, title="Difference neurons")
rplt.show()
def visualize(self, plots = "hvrs"):
"""2*2 grid with of 5*1 rows"""
n_mcs = self.hc.params["n_minicolumns"]
t_sim = self.hc.params["t_sim"]
n_bins = 100
bins = np.linspace(0,t_sim,n_bins+1)
bin_size =t_sim/n_bins
# Spike histograms
if "h" in plots:
f, axarr= plt.subplots(n_mcs+1,sharex=True)
plt.xlabel("Time (ms)")
f.subplots_adjust(hspace=0.05)
for i, sd in enumerate(self.hc.spikedetectors[::-1]):
axarr[i].set_yticks([0,100])
axarr[i].set_ylim([0, 200])
axarr[i].set_xlim([0, t_sim])
axarr[i].xaxis.labelpad = 2
axarr[i].yaxis.labelpad = 2
events = nest.GetStatus([sd],"events")[0]
times = events["times"]
#self.setTickSize(axarr[i])
if not i == 0: # Om inte inhibitory pop..
norm_factor = 1000.0/(bin_size*self.hc.params["N_E"])
else: # ..som har annat antal neuroner
norm_factor = 1000.0/(bin_size*self.hc.params["N_I"])
h_weights = [norm_factor]*len(times)
text2 = "%.1f" %(self.hc.spike_statistics[n_mcs-i])
#axarr[i].text(0.85, 0.78, text2, transform = axarr[i].transAxes, fontsize = 10)
if i == 0:
axarr[i].set_ylim([0, 250])
axarr[i].set_yticks([0,100,200])
text = "(" + str(int(sum(self.hc.inrates)*self.hc.params["p_in_bas"])) +")"
#axarr[i].axhspan(0,t_sim, facecolor="grey", alpha =0.3)
axarr[i].set_axis_bgcolor("0.90")
#axarr[i].xaxis.set_ticks_position("bottom")
#axarr[i].yaxis.set_ticks_position("left")
else:
text = "(" + str(int(self.hc.inrates[n_mcs-i])) + ")"
axarr[i].yaxis.set_ticks_position("left")
axarr[i].text(1.02, 0.20, text + "\n" + text2, transform = axarr[i].transAxes, fontsize=8)
if len(times):
axarr[i].hist(times, bins, weights=h_weights, linewidth=0.5) # vikta staplarna for att fa i <Hz>
f.text(0.06, 0.5, 'Spike frequency (Hz)', ha='center', va='center', rotation='vertical', fontsize=8)
#
# Voltage trace plots
if "v" in plots:
f, axarr= plt.subplots(n_mcs+1,sharex=True)
plt.xlabel("Time (ms)")
f.subplots_adjust(hspace=0.05)
for i, vm in enumerate(self.hc.voltmeters[::-1]):
if i == 0:
axarr[i].set_axis_bgcolor("0.90")
text = "(" + str(int(sum(self.hc.inrates)*self.hc.params["p_in_bas"])) +")"
else:
text = "(" + str(int(self.hc.inrates[n_mcs-i])) + ")"
axarr[i].set_ylim([-5, 22])
axarr[i].set_xlim([0, t_sim])
axarr[i].set_yticks([0,10])
axarr[i].xaxis.labelpad = 2
axarr[i].yaxis.labelpad = 2
#self.setTickSize(axarr[i],10)
simple_plots.voltage_trace2(axarr[i], [vm])
axarr[i].yaxis.set_ticks_position("left")
axarr[i].text(1.02, 0.4, text, transform = axarr[i].transAxes, fontsize=8)
f.text(0.06, 0.5, 'Membrane voltage (mV)', ha='center', va='center', rotation='vertical', fontsize=8)
# plt.show()
# Raster plots
if "r" in plots:
f, ax = plt.subplots(1)
ax.xaxis.labelpad = 1
plt.xlabel("Time (ms)")
all_text = ""
for i in range(self.hc.params["n_minicolumns"]+1):
if i==0:
text = "(" + str(int(sum(self.hc.inrates)*self.hc.params["p_in_bas"])) +")"
ax.text(1.02, 0.92, text , transform = ax.transAxes, fontsize=8)
else:
text = "(" + str(int(self.hc.inrates[n_mcs-i])) + ")"+"\n"
all_text += text +"\n\n"
ax.text(1.02, -0.1, all_text , transform = ax.transAxes, fontsize=8)
ax.set_yticks(np.arange(self.hc.all_pyr[0], self.hc.all_pyr[-1]+1, 30))
ax.grid(True,'major','y',linestyle='-')
plt.setp(ax.get_yticklabels() , visible=False)
raster_plot.from_device(self.hc.raster_spikedetector, title="")
plt.ylim(self.hc.all_pyr[0],self.hc.basket_cells[-1]+0.5)
#ax.axhspan(self.hc.basket_cells[-1],self.hc.basket_cells[0]-0.5, facecolor="grey", alpha =0.3)
ax.axhspan(self.hc.all_pyr[-1]+0.5,self.hc.basket_cells[-1]+0.5, facecolor="0.9", linewidth=0.5)
plt.ylabel("Model neuron id")
# Plot over spike distribution
if "s" in plots:
f, axarr= plt.subplots(n_mcs+1,sharex=False)
f.subplots_adjust(hspace=0.1)
for m in range(n_mcs+1):
spike_statistics_mc, neurons = hcu.spike_frequency_analysis(self.hc, n_mcs-m)
std, mean = np.std(spike_statistics_mc), np.mean(spike_statistics_mc)
spike_statistics_mc.sort()
axarr[m].bar(range(len(spike_statistics_mc)),spike_statistics_mc,linewidth=0.5, width=1.0)
l, = axarr[m].plot([0,30],[mean, mean],"--k",linewidth=0.75)
l.set_dashes([3,4])
#text = "Spikefrequency: %.2f +/- %.2f" % (mean,std)
#axarr[m].text(0.5, 0.7, text, transform = axarr[m].transAxes, fontsize=8)
plt.setp(axarr[m].get_xticklabels() , visible=False)
axarr[m].yaxis.set_ticks_position("left")
axarr[m].xaxis.set_ticks_position("none")
axarr[m].set_xlim([0,30])
if m != 0:
axarr[m].set_ylim([0, 200])
axarr[m].set_yticks([0,100])
text = "(" + str(int(self.hc.inrates[n_mcs-m])) + ")"
else:
axarr[m].set_axis_bgcolor("0.90")
axarr[m].set_ylim([0, 200])
axarr[m].set_yticks([0,100])
text = "(" + str(int(sum(self.hc.inrates)*self.hc.params["p_in_bas"])) +")"
axarr[m].text(1.02, 0.4, text, transform = axarr[m].transAxes, fontsize=8)
plt.xlabel("Model neuron id")
plt.show()
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')
new_position, outcome, in_end_position = env.move(possible_actions[chosen_action])
nest.SetStatus(wta_noise, {'rate': 0.})
for t in range(4):
nest.Simulate(5)
time.sleep(0.01)
last_action_time += 60
actions_executed += 1
else:
position = env.get_agent_pos().copy()
_, in_end_position = env.init_new_trial()
nest.SetStatus(nest.GetConnections(stimulus, states[position['x']][position['y']]), {'weight': 0.})
rplt.from_device(sd_wta, title="WTA circuit")
rplt.from_device(sd_states, title="states")
rplt.show()
#fig = plt.figure()
#plt.xlabel("# action")
#plt.ylabel("valence")
#plt.title("valence of each action")
#ax = fig.add_subplot(111, projection='3d')
#x, y = np.meshgrid(range(world_dim['x'] * num_actions), range(NUM_ITERATIONS))
#x = x.flatten()
#y = y.flatten()
#ax.bar3d(x, y, np.zeros(len(x)), np.ones(len(x)) * 0.5, np.ones(len(x)) * 0.5, np.ravel(values_hist))
Plot membrane potential trace (recorder neurons gray + average in blue)
Write your code here
--------------------
Write a function or a just a piece of code that plots the membrane traces of the
recorded neurons in gray. Calculate the average and plot it in a different color.
Please note that svi,tvi,pvi have been already converted into numpy arrays.
"""
hlp.plot_Vm_traces(svi, tvi, pvi)
pylab.xlabel("time(ms)", fontsize=30)
pylab.ylabel("potential(mV)", fontsize=30)
rplt.from_device(sd_i)
"""
Plot rate histogram
Write your code here
--------------------
Calculate the number of spikes emitted by each neuron and store
results in a rate vector, which you can then apply hist to
"""
unique_senders = np.unique(si)
rates = np.array([])
for s in unique_senders:
rates = np.append(rates, len(np.where(si == s)[0]))
nest.Connect(multimeter, [gids[0]])
start = time.time()
nest.Simulate(sim_time)
lst_times[j][i] = time.time() - start
lst_spikes[j][i] = len(nest.GetStatus(sd)[0]["events"]["senders"]) / sim_time
dmm = nest.GetStatus(multimeter)[0]
da_voltage = dmm["events"]["V_m"]
da_adapt = dmm["events"][lst_record[j]]
da_time = dmm["events"]["times"]
ax1.plot(da_time,da_voltage,c=cm.hot(j/float(num_models)), label=models[j])
ax1.set_ylabel('Voltage (mV)')
ax2.plot(da_time,da_adapt,c=cm.hot(j/float(num_models)), label=models[j])
ax2.set_xlabel('Time (ms)')
ax2.set_ylabel(lst_ylabel[j])
from_device(sd, title="Raster for {} neurons of type {}".format(size, model))
fig, (ax1, ax2) = plt.subplots(2,1,sharex=True)
for i, model in enumerate(models):
ax1.plot(lst_network_sizes, lst_times[i], c=cm.hot(i/float(num_models)), label=model)
ax2.scatter(lst_network_sizes, lst_spikes[i], c=cm.hot(i/float(num_models)), label=model)
ax2.set_xlabel("Network size")
ax1.set_ylabel("Simulation time")
ax2.set_ylabel("Number of spikes")
ax1.legend(loc=2)
ax2.legend(loc=2)
plt.show()
import os.path
data_folder = './data/detectors'
if not os.path.isdir(data_folder):
os.makedirs(data_folder)
figure_folder = './figures/detectors'
if not os.path.isdir(figure_folder):
os.makedirs(figure_folder)
# save raster plot and data
for name, r in detectors.items():
rec = r[0]
# raster plot
p = raster_plot.from_device(rec, hist=True)
f = p[0].figure
f.set_size_inches(5, 3)
f.savefig(figure_folder + '/spikes_' + name + '.png', dpi=300)
# data
spikes = nest.GetStatus(rec, "events")[0]
print('Saving spikes for ' + name)
with open(data_folder + '/spikes_' + name + '.pickle', 'w') as f:
pickle.dump(spikes, f)
scipy.io.savemat(data_folder + '/spikes_' + name + '.mat',
mdict={
'senders': spikes['senders'],
'times': spikes['times']
})
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):
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):
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')
nest.SetStatus(proxy_sensory, [{'port_name': 'sensory', 'music_channel': c} for c in range(100)])
nest.SetAcceptableLatency('sensory', 2.0)
print("Create devices")
sd_sensory = nest.Create("spike_detector", 1)
print("Connect")
# proxy to sd
nest.Connect(proxy_sensory, sd_sensory)
print("Simulate")
comm.Barrier()
nest.Simulate(10000)
print("Done")
rplt.from_device(sd_sensory)
rplt.show()
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')
