def build_network_connections(spikeSequence, data, inputLayer, outputLayer):
# Get generated spike sequence for each layer
inputSpikeSequence = spikeSequence[0]
outputSpikeSequence = spikeSequence[1]
# Total number of data items
totalNumberOfDataItems = len(data)
# Loop through all data items
for eachWine in range(0, totalNumberOfDataItems):
dataItem = data[eachWine]
# === Presynaptic layer ==
# Gets presynaptic connections for each data item
inputConnector = generate_feature_connections(dataItem, eachWine)
inputFromListConnector = sim.FromListConnector(inputConnector)
sim.Projection(inputSpikeSequence,
inputLayer,
inputFromListConnector,
receptor_type='excitatory')
# === Postsynaptic layer ===
outputClass = dataItem[0] - 1 # -1 so the classes are from 0, 1 and 2.
outputConnector = [(eachWine, outputClass, FIRING_WEIGHT, TIME_STEP)]
outputFromListConnector = sim.FromListConnector(outputConnector)
sim.Projection(outputSpikeSequence,
outputLayer,
outputFromListConnector,
receptor_type='excitatory')
def conv_pops(pop1, pop2, w):
in_size = int(np.sqrt(pop1.size))
out_size = int(np.sqrt(pop2.size))
conn_exci, conn_inhi = conv_conn(in_size, out_size, w)
if len(conn_exci)>0:
p.Projection(pop1, pop2, p.FromListConnector(conn_exci), target='excitatory')
if len(conn_inhi)>0:
p.Projection(pop1, pop2, p.FromListConnector(conn_inhi), target='inhibitory')
return
def fcLayer_Proj(pre_pop, cnn_fcLayer, cell_params, num_label):
exci_conn, inhi_conn = fcLayer_Connect(cnn_fcLayer, num_label)
post_pop = sim.Population(num_label, sim.IF_curr_exp, cell_params)
if len(exci_conn) > 0:
sim.Projection(pre_pop, post_pop, sim.FromListConnector(exci_conn), target='excitatory')
if len(inhi_conn) > 0:
sim.Projection(pre_pop, post_pop, sim.FromListConnector(inhi_conn), target='inhibitory')
return post_pop
def out_pops(pop_list, pop2, w_layer):
in_size = pop_list[0].size
out_size = pop2.size
for i in range(len(pop_list)):
w = w_layer[:,i*in_size:(i+1)*in_size]
conn_exci, conn_inhi = out_conn(w)
if len(conn_exci)>0:
p.Projection(pop_list[i], pop2, p.FromListConnector(conn_exci), target='excitatory')
if len(conn_inhi)>0:
p.Projection(pop_list[i], pop2, p.FromListConnector(conn_inhi), target='inhibitory')
return
def convLayer_Proj(pre_pop, cnn_convLayer, cell_params):
output_depth = cnn_convLayer.num_Filters
output_size = (len(cnn_convLayer.input_volume[0]) - cnn_convLayer.filter_Size + 2*cnn_convLayer.pad)/cnn_convLayer.stride + 1
post_pop = sim.Population(np.prod((output_depth, output_size, output_size)), sim.IF_curr_exp, cell_params)
exci_conn, inhi_conn = convLayer_Connect(cnn_convLayer)
if len(exci_conn) > 0:
sim.Projection(pre_pop, post_pop, sim.FromListConnector(exci_conn), target='excitatory')
if len(inhi_conn) > 0:
sim.Projection(pre_pop, post_pop, sim.FromListConnector(inhi_conn), target='inhibitory')
return post_pop
def pool_pops(pop1, pop2, w):
in_size = int(np.sqrt(pop1.size))
out_size = int(np.sqrt(pop2.size))
conn_exci = pool_conn(in_size, out_size, w)
if len(conn_exci)>0:
p.Projection(pop1, pop2, p.FromListConnector(conn_exci), target='excitatory')
return
def test_create_with_homogeneous_common_properties(self):
with self.assertRaises(ValueError):
# create synapse type with heterogeneous common parameters
fromlist = sim.FromListConnector(conn_list=[
(0, 0, 10., 100.), (1, 1, 10., 200.)],
column_names=["weight", "Wmax"])
prj = sim.Projection(self.p1, self.p2, fromlist,
synapse_type=self.native_synapse_type())
def poolLayer_Proj(pre_pop, cnn_poolLayer, cell_params):
conn = poolLayer_Connect(cnn_poolLayer)
output_depth = len(cnn_poolLayer.input_volume)
output_size = (len(cnn_poolLayer.input_volume[0]) - cnn_poolLayer.filter_Size)/cnn_poolLayer.stride + 1
post_pop = sim.Population(np.prod((output_depth, output_size, output_size)), sim.IF_curr_exp, cell_params)
if len(conn) > 0:
sim.Projection(pre_pop, post_pop, sim.FromListConnector(conn), target='excitatory')
return post_pop
def build_testing_connections(testSpikeSources, data, testInputLayer):
numberDataItems = len(data)
# Loop through all data elements (89 for wine test data)
for element in range(0, numberDataItems):
dataItem = data[element]
# Get connections for each data item
testConnector = generate_feature_connections(dataItem, element)
testFromListConnector = sim.FromListConnector(testConnector)
sim.Projection(testSpikeSources,
testInputLayer,
testFromListConnector,
receptor_type='excitatory')
def connect_testing_layers(inputLayer, outputLayer, synapses):
connector = []
for synapseOffset in range(0, len(synapses)):
fromNeuron = synapses[synapseOffset][0]
toNeuron = synapses[synapseOffset][1]
weight = synapses[synapseOffset][2]
connector = connector + [(fromNeuron, toNeuron, weight, TIME_STEP)]
testFromListConnector = sim.FromListConnector(connector)
sim.Projection(inputLayer,
outputLayer,
testFromListConnector,
receptor_type='excitatory')
label=label)
# Set the rest of the specified variables, if any.
for variable in s['variables']:
if getattr(population, variable, None) is None:
setattr(population, variable, s[label][variable])
if label != 'InputLayer':
population.set(i_offset=s[label]['i_offset'])
layers.append(population)
print('assembly loaded')
# ------ Load weights and delays --------
for i in range(len(layers) - 1):
print('Loading connections for layer ' + str(layers[i].label))
filepath = os.path.join(layers_path, layers[i + 1].label)
conn_list = read_from_file2list(filepath)
exc_connector = sim.FromListConnector(conn_list[0])
pro_exc = sim.Projection(layers[i],
layers[i + 1],
connector=exc_connector,
receptor_type='excitatory')
if conn_list[1] != []:
inh_connector = sim.FromListConnector(read_from_file2list(filepath)[1])
pro_inh = sim.Projection(layers[i],
layers[i + 1],
connector=inh_connector,
receptor_type='inhibitory')
print('connections loaded')
# -------- Cell initialization -----------
#vars_to_record = ['spikes','v']
#if 'spikes' in vars_to_record:
spike_2_conn_for_2 = sim.Projection(spike_source_2, cann_pop[2:3],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
spike_2_conn_for_3 = sim.Projection(spike_source_3, cann_pop[3:4],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
spike_2_conn_for_4 = sim.Projection(spike_source_4, cann_pop[4:5],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
spike_2_conn_for_9 = sim.Projection(spike_source_9, cann_pop[9:10],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
cann_2_cann = sim.Projection(
cann_pop, cann_pop,
sim.FromListConnector(cann_connector, column_names=["weight"]),
sim.StaticSynapse(weight=0.0001, delay=75))
cann_2_inh = sim.Projection(cann_pop,
inhib_pop,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.02, delay=0.1),
receptor_type="excitatory")
inh_2_cann = sim.Projection(inhib_pop,
cann_pop,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.2, delay=0.1),
receptor_type="inhibitory")
#spike_source.record('spikes')
spike_times = [1000., 2000.]
cann_pop = sim.Population(n, sim.IF_cond_alpha(**cell_params),
label = "cann_pop")
inhib_pop = sim.Population(1, sim.IF_cond_alpha(**cell_params),
label = "inhib_pop")
spike_source = sim.Population(1, sim.SpikeSourceArray(
spike_times = spike_times))
spike_2_conn = sim.Projection(spike_source, cann_pop[spiky:spiky+1], sim.AllToAllConnector(),
sim.StaticSynapse(weight = 0.002, delay = 0.1))
cann_2_cann = sim.Projection(cann_pop, cann_pop, sim.FromListConnector(cann_connector, column_names=["weight"]),
sim.StaticSynapse(weight = 0.0001, delay = 75))
cann_2_inh = sim.Projection(cann_pop, inhib_pop, sim.AllToAllConnector(),
sim.StaticSynapse(weight = 0.02, delay = 0.1),
receptor_type = "excitatory")
inh_2_cann = sim.Projection(inhib_pop, cann_pop, sim.AllToAllConnector(),
sim.StaticSynapse(weight = 0.2, delay = 0.1),
receptor_type = "inhibitory")
spike_source.record('spikes')
cann_pop.record(('v','spikes'))
inhib_pop.record(('v','spikes'))
sim.run(5000.0)
fc0.initialize(**cellvalues)
fc0.set(v_thresh=vth0)
fc1 = sim.Population(w1.shape[0], fc_celltype)
fc1.initialize(**cellvalues)
fc1.set(v_thresh=vth1)
#fc1.set(i_offset=b1)
fc2 = sim.Population(10, fc_celltype)
fc2.initialize(**cellvalues)
fc2.set(v_thresh=vth2)
#fc2.set(i_offset=b2)
proj0 = sim.Projection(input_pop,
fc0,
connector=sim.FromListConnector(conns_0))
proj1 = sim.Projection(fc0, fc1, connector=sim.FromListConnector(conns_1))
proj2 = sim.Projection(fc1, fc2, connector=sim.FromListConnector(conns_2))
#input_pop.record('spikes')
fc0.record(['spikes', 'v'])
#fc1.record(['spikes','v'])
#fc2.record(['spikes','v'])
fc2.record(['spikes'])
sim.run(duration - dt)
#spiketrains_i = input_pop.get_data().segments[-1].spiketrains
#spiketrains_0 = fc0.get_data().segments[-1].spiketrains
#spiketrains_1 = fc1.get_data().segments[-1].spiketrains
spiketrains_2 = fc2.get_data().segments[-1].spiketrains
stdp_weight = np.load('%s/weight_%d.npy' % (directory, (run_i - 1)))
proj_stdp = p.Projection(
#pop_input, pop_output, p.AllToAllConnector(weights = weight_distr),
pop_input,
pop_output,
p.AllToAllConnector(weights=stdp_weight),
synapse_dynamics=p.SynapseDynamics(slow=stdp_model))
for i in range(num_output):
conn_list = list()
for j in range(num_output):
if i != j:
conn_list.append((i, j, -18.1, 1.0))
p.Projection(pop_output,
pop_output,
p.FromListConnector(conn_list),
target='inhibitory')
for i in range(num_train * num_epo):
p.Projection(TeachingPoission[i],
pop_output,
ee_connector,
target='excitatory')
#pop_input.record()
pop_output.record()
pre = proj_stdp.getWeights(format='array', gather=False)
#print pre
p.run(1.0 * num_epo * num_train * (dur_train + silence))
post = proj_stdp.getWeights(format='array', gather=False)
np.save('%s/weight_%d.npy' % (directory, run_i), post)
'''
# ======================================================================================================
# create interpopulation projections
projections_inp_hiddenP = []
for idx, pop in enumerate(hidden_populations[:N_uninverted]):
projection_inp_hiddenP = sim.Projection(input_populations[0], pop[0], sim.FixedProbabilityConnector(p_connect=Pconnect_input[idx]),
sim.StaticSynapse(weight=weights_input[idx,0])) #input_weights[idx,0] [neuron.weights for x in range(hiddenP_size)]
projections_inp_hiddenP.append(projection_inp_hiddenP) # ? is it necessary to store them in a list ?
for idx, pop in enumerate(hidden_populations[N_uninverted:]):
projection_inp_hiddenP = sim.Projection(input_populations[1], pop[0], sim.FixedProbabilityConnector(p_connect=Pconnect_input[idx+N_uninverted]),
sim.StaticSynapse(weight=weights_input[idx+N_uninverted,0])) #input_weights[idx,0] [neuron.weights for x in range(hiddenP_size)]
projections_inp_hiddenP.append(projection_inp_hiddenP) # ? is it necessary to store them in a list ?
#projections_hiddenP_monitor
for idx in range(N_res):
connector = sim.FromListConnector(conn_list=[(x,idx) for x in range(hiddenPexc_size)])
projection=sim.Projection(hidden_populations[idx][0], monitor_population, connector, sim.StaticSynapse(weight=1.0))
projections_hiddenP_readout = []
connector = sim.AllToAllConnector() #FixedProbabilityConnector(p_connect=0.14) , delays=np.random.randint(6,72), rng=rng
for idx0 in range(N_readouts):
readout_pop = readout_neuron_populations[idx0]
projections = []
for idx1 in range(N_res):
pop0exc = hidden_populations[idx1][0]
weight = weights_readout[idx0][idx1, 0]
projection = sim.Projection(pop0exc, readout_pop, connector, sim.StaticSynapse(weight=weight))
projections.append(projection)
projections_hiddenP_readout.append(projections)
def setup(self):
# set up layers according to backend
self.layers = []
if self.backend == 'spinnaker':
spin_sim.setup(timestep=1.0, time_scale_factor=1.0, min_delay=1.0, max_delay=None)
# set neuron hyperparameters
# tau_m should not be set too high, because it can easily lead to an overflow
ctx_parameters = {'cm': 1.0, 'i_offset': 0.0, 'tau_m': 100.0, 'tau_refrac': 0.0,
'v_reset': 0.0, 'v_rest': 0.0, 'v_thresh': 1.0}
tc_parameters = ctx_parameters.copy()
neuron_type = extra_models.IFCurDelta(**tc_parameters)
for l in range(0,len(self.weights)):
self.layers.append(spin_sim.Population(self.architecture[l+1], neuron_type,
initial_values={'v': 0.0}))
# set output layer threshold: must be set high enough s.t. output neurons do not spike,
# must not be set too high to avoid overflow
self.layers[-1].set(v_thresh=10000.0)
elif self.backend == 'nest':
nest_sim.setup(timestep=1.0, min_delay=1.0)
# set neuron type, currently only supports iaf_psc_delta and one set of hyperparameters
neuron_type = nest_sim.native_cell_type('iaf_psc_delta')
for l in range(0, len(self.weights)-1):
self.layers.append(nest_sim.Population(self.architecture[l+1],
neuron_type(V_th=1.0, t_ref=0.0,
V_min=-np.inf, C_m=1.0,
V_reset=0.0, tau_m=10.0**10,
E_L=0.0, I_e=0.0)))
self.layers[l].initialize(V_m=0.0)
# set up output layer seperately with infinite threshold
self.layers.append(nest_sim.Population(self.architecture[-1],
neuron_type(V_th=np.inf, t_ref=0.0,
V_min=-np.inf, C_m=1.0, V_reset=0.0,
tau_m=10.0 ** 10, E_L=0.0, I_e=0.0)))
self.layers[-1].initialize(V_m=0.0)
elif self.backend == 'pynn':
raise Exception('Current implementation does not support native pynn types. '
'Code after this exception acts as an example on how native pynn types'
'are used and can be modified. Additionally, the backend still needs to'
'be specified and is set to nest in the code below.')
# the following out-commented lines show how a native pynn type would be used
'''
nest_sim.setup(timestep=1.0, time_scale_factor=1.0, min_delay=1.0, max_delay=None)
# conductive exponential neuron as an example
ctx_parameters = {'cm': 1.0, 'e_rev_E': 0.0, 'e_rev_I': -65.0, 'i_offset': 0.0, 'tau_m': 10000.0, 'tau_refrac': 0.0, 'tau_syn_E': 0.01, 'tau_syn_I': 0.01, 'v_reset': -65.0, 'v_rest': -65.0, 'v_thresh': -64.0}
#tc_parameters = ctx_parameters.copy()
neuron_type = sim.IF_cond_exp(**tc_parameters)
for l in range(0,len(self.weights)):
self.layers.append(sim.Population(self.architecture[l+1], neuron_type, initial_values={'v': 0.0}))
# output layer should not spike
self.layers[-1].set(v_thresh=np.inf)
'''
else:
raise Exception('backend not supported')
# connect layers (input layer is connected to first in simulate by setting offsets
for l in range(0, len(self.layers)-1):
excitatory_connections = []
inhibitory_connections = []
# 1 and 2
for i in range(0, len(self.layers[l])):
for j in range(0, len(self.layers[l+1])):
if self.weights[l+1][i][j].detach().item() >= 0:
excitatory_connections.append((i, j,
self.weights[l+1][i][j].detach().item(),1.0))
else:
inhibitory_connections.append((i, j,
self.weights[l+1][i][j].detach().item(),1.0))
# when using NEST or native PyNN models, connect has to be called explicitly, when using
# SpiNNaker connecting happens automatically
if self.backend == 'pynn' or self.backend == 'nest':
excitatory_connector = nest_sim.FromListConnector(excitatory_connections,
column_names=["weight", "delay"])
excitatory_projection = nest_sim.Projection(self.layers[l], self.layers[l + 1],
connector=excitatory_connector)
excitatory_connector.connect(excitatory_projection)
elif self.backend == 'spinnaker':
excitatory_connector = spin_sim.FromListConnector(excitatory_connections,
column_names=["weight", "delay"])
excitatory_projection = spin_sim.Projection(self.layers[l], self.layers[l + 1],
connector=excitatory_connector)
# when using NEST or native PyNN models, connect has to be called explicitly, when using
# SpiNNaker connecting happens automatically
if self.backend == 'pynn' or self.backend == 'nest':
inhibitory_connector = nest_sim.FromListConnector(inhibitory_connections,
column_names=["weight", "delay"])
inhibitory_projection = nest_sim.Projection(self.layers[l], self.layers[l + 1],
inhibitory_connector,
receptor_type='inhibitory')
inhibitory_connector.connect(inhibitory_projection)
elif self.backend == 'spinnaker':
inhibitory_connector = spin_sim.FromListConnector(inhibitory_connections,
column_names=["weight", "delay"])
inhibitory_projection = spin_sim.Projection(self.layers[l], self.layers[l + 1],
inhibitory_connector,
receptor_type='inhibitory')
# set biases (constant input currents)
for l in range(0,len(self.layers)):
for i in range(0,len(self.layers[l])):
# use i_offset on spynnaker instead of DCSource
offset = self.biases[l][i].detach().item()
if self.backend == 'nest':
self.layers[l][i:i+1].set(I_e=offset)
elif self.backend == 'pynn' or self.backend=='spinnaker':
self.layers[l][i:i+1].set(i_offset=offset)
# record the potentials of the last layer
if self.backend == 'nest' or self.backend == 'pynn':
self.layers[-1].record('V_m')
elif self.backend == 'spinnaker':
self.layers[-1].record('v')
t2 = [[2,3,4,8],[2,4,6,8]]
t1 = [2,12]
input_celltype = sim.SpikeSourceArray(spike_times=t2)
fc_celltype = sim.IF_cond_exp(**cellparams)
pop0 = sim.Population(2,input_celltype)
pop1 = sim.Population(1, fc_celltype)
pop1.initialize(**cellvalues)
#pop1.set(i_offset=b)
pop1.record(['spikes','v'])
pop0.record(['spikes'])
# create synapsis
conn = sim.FromListConnector(w2)
pro = sim.Projection(pop0, pop1, connector=conn)
sim.run(duration)
mem = pop1.get_data().segments[-1].analogsignals[0]
sp0 = pop0.get_data().segments[-1].spiketrains
sp1 = pop1.get_data().segments[-1].spiketrains
from pyNN.utility.plotting import Figure, Panel
Figure(
Panel(mem, ylabel="Membrane potential (mV)", xticks=True,
xlabel="Time (ms)", yticks=True))
# Create list of connections
cortical_inh_exc_connections = create_cortical_to_cortical_connection(
cortical_neurons_inh,
cortical_neurons_exc,
orientations_inh,
phases_inh,
orientations_exc,
phases_exc,
orientation_sigma,
phase_sigma,
g_exc,
n_pick,
target_type_excitatory=False)
# Make the list a connector
cortical_inh_exc_connector = simulator.FromListConnector(
cortical_inh_exc_connections, column_names=["weight", "delay"])
# Projections
#cortical_inh_exc_projection = simulator.Projection(cortical_neurons_inh, cortical_neurons_exc,
# cortical_inh_exc_connector, receptor_type='inhibitory')
## Now we create the excitatory connections
if cortical_excitatory_feedback:
# Create list of connectors
cortical_exc_exc_connections = create_cortical_to_cortical_connection(
cortical_neurons_exc,
cortical_neurons_exc,
orientations_exc,
phases_exc,
orientations_exc,
for j in range(weights[layer].shape[0]):
if float(weights[layer][j, i]) < 0.0:
inh_synapses.append([i, j, -1.0 * weights[layer][j, i], delay])
else:
exc_synapses.append([i, j, weights[layer][j, i], delay])
pops.append(sim.Population(weights[layer].shape[0], fc_celltype))
vth = v_th - biases[layer]
vth[vth < 0.0] = 0.001
pops[layer + 1].set(v_thresh=vth)
sim.Projection(pops[layer],
pops[layer + 1],
connector=sim.FromListConnector(inh_synapses),
receptor_type='inhibitory')
sim.Projection(pops[layer],
pops[layer + 1],
connector=sim.FromListConnector(exc_synapses),
receptor_type='excitatory')
pops[-1].record(['spikes'])
pops[0].record(['spikes'])
pops[1].record(['spikes', 'v'])
num_to_test = 10
acc = 0.0
num_timesteps = duration / dt
#spike_2_conn_for_9 = sim.Projection(spike_source_9, hd_cann_pop[9:10], sim.OneToOneConnector(),
# sim.StaticSynapse(weight = 0.002, delay = 0.1))
pos_spikes = sim.Projection(pos_spike_src, pos_rot_conj[3:4],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.2, delay=0.1))
neg_spikes = sim.Projection(neg_spike_src, neg_rot_conj[4:5],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.2, delay=0.1))
# Connections/ Projections
hd_cann_2_hd_cann = sim.Projection(
hd_cann_pop, hd_cann_pop,
sim.FromListConnector(hd_cann_connector, column_names=["weight"]),
sim.StaticSynapse(weight=0.0001, delay=75))
hd_cann_2_inh = sim.Projection(hd_cann_pop,
inhib_pop,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.02, delay=0.1),
receptor_type="excitatory")
inh_2_hd_cann = sim.Projection(inhib_pop,
hd_cann_pop,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.5, delay=0.1),
receptor_type="inhibitory")
for i in range(n):
target='inhibitory')
elif sim_test == 'spin':
p.set_number_of_neurons_per_core("IF_curr_exp", 127)
pop_poisson = p.Population(input_size * input_size, p.SpikeSourceArray,
{'spike_times': spike_source_data})
ee_connector = p.OneToOneConnector(weights=3.0)
pop_input = p.Population(input_size * input_size, p.IF_curr_exp,
cell_params_lif)
p.Projection(pop_poisson, pop_input, ee_connector, target='excitatory')
pop_output = p.Population(num_output, p.IF_curr_exp, cell_params_lif)
conn_list_exci = allToall2ConnectList(trained_weights, 1.0)
conn_list_inhi = allToall2ConnectList(negtive_weights, 1.0)
p.Projection(pop_input,
pop_output,
p.FromListConnector(conn_list_exci),
target='excitatory')
p.Projection(pop_input,
pop_output,
p.FromListConnector(conn_list_inhi),
target='inhibitory')
'''
for i in range(num_output):
conn_list = list()
for j in range(num_output):
#if np.ceil(i/num_digit) != np.ceil(j/num_digit):
if i!= j:
conn_list.append((i, j, -1.1, 1.0)) #-1.1
p.Projection(pop_output, pop_output, p.FromListConnector(conn_list), target='inhibitory')
print 'WTA:, ', i
'''
'cm': 0.2,
'v_offset': -63.0,
'e_rev_Na': 50.0,
'e_rev_K': -90.0,
'e_rev_leak': -65.0,
'e_rev_E': 0.0,
'e_rev_I': -80.0,
'tau_syn_E': 10.0,
'tau_syn_I': 2.0,
'i_offset': 0.0,
})
pop_cond_exp.record(["spikes", "v"])
sim.Projection(source,
pop_cond_exp,
connector=sim.FromListConnector([(0, 0, 0.1, 0.1)]))
sim.run(1000.0)
print "Conductance based exponential HH neuron"
print pop_cond_exp.get_data().segments[0].spiketrains
voltage_trace = pop_cond_exp.get_data().segments[0].analogsignalarrays[0]
n = len(voltage_trace)
arr = np.zeros((n, 2))
arr[:, 0] = np.linspace(0, timestep * (n - 1), n)
arr[:, 1] = voltage_trace[:, 0]
np.savetxt("hh_trace_pynn.csv", arr, delimiter=",")
sim.end()
