postStd,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=-5.0),
receptor_type='inhibitory',
label='inh_proj',
)
sProj = sim.Projection(
preInh,
postShunt,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=-5.0),
receptor_type='inhShunt',
label='shunt_proj',
)
sim.run(runtime)
data_exc = preExc.get_data().segments[0]
data_inh = preInh.get_data().segments[0]
data_std = postStd.get_data().segments[0]
data_shunt = postShunt.get_data().segments[0]
sim.end()
figsize = (15, 5)
plot_data(data_exc, data_inh, data_shunt, title='shunt', figsize=figsize)
plt.tight_layout()
plot_data(data_exc, data_inh, data_std, title='standard', figsize=figsize)
plt.tight_layout()
plt.show()
label='pre')
params['tau_syn_E'] = 5.
post = sim.Population(n_neurons, sim.IF_curr_exp, params,
label='post')
post.record('spikes')
dist_params = {'low': 0.0, 'high': 10.0}
dist = 'uniform'
rand_dist = RandomDistribution(dist, rng=rng, **dist_params)
var = 'weight'
on_device_init = bool(1)
conn = sim.AllToAllConnector()
syn = sim.StaticSynapse(weight=5./n_neurons, delay=1)#rand_dist)
proj = sim.Projection(pre, post, conn, synapse_type=syn, use_procedural=bool(0))
sim.run(2 * n_neurons)
data = post.get_data()
spikes = np.asarray(data.segments[0].spiketrains)
sim.end()
all_at_appr_time = 0
sum_spikes = 0
for i, times in enumerate(spikes):
sum_spikes += len(times)
if int(times[0]) == 9:
all_at_appr_time += 1
assert sum_spikes == n_neurons
assert all_at_appr_time == n_neurons
#each neuron spikes once because
params = copy.copy(sim.IF_curr_exp.default_parameters)
pre = sim.Population(n_pre, sim.IF_curr_exp, params, label='pre')
post = sim.Population(n_post, sim.IF_curr_exp, params, label='post')
dist_params = {'low': 0.0, 'high': 10.0}
dist = 'uniform'
rand_dist = RandomDistribution(dist, rng=rng, **dist_params)
var = 'weight'
on_device_init = bool(1)
p_conn = 0.3
n = 30 #int(n_post * p_conn)
conn = sim.FixedNumberPostConnector(n, rng=rng, with_replacement=True)
syn = sim.StaticSynapse(weight=rand_dist, delay=1) #rand_dist)
proj = sim.Projection(pre, post, conn, synapse_type=syn)
sim.run(10)
comp_var = np.asarray(proj.getWeights(format='array'))
shape = np.copy(comp_var.shape)
n_cols = []
for r in comp_var:
n_cols.append(len(np.where(~np.isnan(r))[0]))
connected = np.where(~np.isnan(comp_var))
comp_var = comp_var[connected]
num_active = comp_var.size
sim.end()
abs_diff = np.abs(n - np.mean(n_cols))
print("abs({} - {}) = {}".format(n, np.mean(n_cols), abs_diff))
inh_cells.record('spikes')
#exc_cells[0, 1].record('v')
buildCPUTime = timer.diff()
# === Save connections to file =================================================
#for prj in connections.keys():
#connections[prj].saveConnections('Results/VAbenchmark_%s_%s_%s_np%d.conn' % (benchmark, prj, options.simulator, np))
saveCPUTime = timer.diff()
# === Run simulation ===========================================================
print("%d Running simulation..." % node_id)
sim.run(tstop)
simCPUTime = timer.diff()
#------------------------------------------------------------------------------
# Plot output
#------------------------------------------------------------------------------
def plot_spiketrains(axis, segment, offset, **kwargs):
for spiketrain in segment.spiketrains:
y = numpy.ones_like(spiketrain) * (
offset + spiketrain.annotations["source_index"])
axis.scatter(spiketrain, y, **kwargs)
def calculate_rate(segment, rate_bins, population_size):
n_spikes = int(np.random.choice(spikes_per_neuron))
spikes = np.round(np.random.choice(max_t, size=n_spikes,
replace=False)).tolist()
spikes[:] = sorted(spikes)
spike_times.append(sorted(spikes))
sources[ssa_id]['times'] = spike_times
ssa = sim.Population(n_neurons[ssa_id],
sim.SpikeSourceArray(spike_times=spike_times),
label='ssa %d' % ssa_id)
ssa.record(['spikes'])
sources[ssa_id]['pop'] = ssa
sim.run(int(1.5 * max_t))
for ssa_id in range(n_ssa):
data = sources[ssa_id]['pop'].get_data()
sources[ssa_id]['spikes'] = spikes_from_data(data)
sources[ssa_id]['data'] = data
sim.end()
for ssa_id in range(n_ssa):
plt.figure()
for nid in range(n_neurons[ssa_id]):
in_spikes = sources[ssa_id]['times']
out_spikes = sources[ssa_id]['spikes']
plt.plot(in_spikes[nid],
# Clear simulation state
sim.setup(min_delay=1.0, max_delay=7.0, timestep=1.0)
# Build inhibitory plasticity model
stdp_model = sim.STDPMechanism(
timing_dependence=sim.Vogels2011Rule(rho=0.12, tau=20.0, eta=0.005),
weight_dependence=sim.AdditiveWeightDependence(w_min=-1.0, w_max=0.0),
weight=0.0,
delay=1.0,
)
# Build plastic network
plastic_ex_pop, plastic_ie_projection = build_network(stdp_model, 10.0)
# Run simulation
sim.run(10000)
# Get plastic spikes and save to disk
plastic_data = plastic_ex_pop.get_data()
plastic_weights = plastic_ie_projection.get("weight",
format="list",
with_address=False)
mean_weight = numpy.average(plastic_weights)
print "Mean learnt ie weight:%f" % mean_weight
def plot_spiketrains(axis, segment, offset, **kwargs):
for spiketrain in segment.spiketrains:
y = numpy.ones_like(spiketrain) * (
offset + spiketrain.annotations["source_index"])
sim.setup(timestep=timestep, min_delay=timestep, backend='SingleThreadedCPU')
post = sim.Population(n_neurons, neuron_class(**base_params))
post.record('spikes')
post.record('v_thresh_adapt')
post.record('v')
pre = sim.Population(
n_neurons,
sim.SpikeSourceArray(spike_times=[[10] for _ in range(n_neurons)]),
)
proj = sim.Projection(pre, post, sim.OneToOneConnector(),
sim.StaticSynapse(weight=3.2))
sim.run(sim_time)
data = post.get_data()
sim.end()
vthresh = data.segments[0].filter(name='v_thresh_adapt')
v = data.segments[0].filter(name='v')
np.savez_compressed("genn_spiking_behaviour.npz", spikes=data.segments[0])
plt.figure()
ax = plt.subplot()
plt.plot(v[0])
plt.plot(vthresh[0])
# plot_spiketrains(data.segments[0])
pylab.rc("text", usetex=True)
labels = [
"Regular spiking", "Fast spiking", "Chattering", "Intrinsically bursting"
]
a = [0.02, 0.1, 0.02, 0.02]
b = [0.2, 0.2, 0.2, 0.2]
c = [-65.0, -65.0, -50.0, -55.0]
d = [8.0, 2.0, 2.0, 4.0]
sim.setup(timestep=0.1, min_delay=0.1, max_delay=4.0)
ifcell = sim.Population(len(labels),
sim.Izhikevich(i_offset=0.01, a=a, b=b, c=c, d=d))
ifcell.record("v")
sim.run(200.0)
data = ifcell.get_data()
sim.end()
figure, axes = pylab.subplots(2, 2, sharex="col", sharey="row")
axes[0, 0].set_ylabel("Membrane potential [mV]")
axes[1, 0].set_ylabel("Membrane potential [mV]")
axes[1, 0].set_xlabel("Time [ms]")
axes[1, 1].set_xlabel("Time [ms]")
signal = data.segments[0].analogsignals[0]
for i, l in enumerate(labels):
axis = axes[i // 2, i % 2]
sim.DCSource(amplitude=1.0,
start=segmentationSignalStart,
stop=simTime))
if len(surfaceOnTarget) > 0:
SurfaceSegmentationOn[surfaceOnTarget].inject(
sim.DCSource(amplitude=1.0,
start=segmentationSignalStart,
stop=simTime))
if len(boundaryOnTarget) > 0:
BoundarySegmentationOn[boundaryOnTarget].inject(
sim.DCSource(amplitude=1.0,
start=segmentationSignalStart,
stop=simTime))
# Actual run of the network, using the input and the segmentation signals
sim.run(stepDuration)
# To store results for later plotting
plotDensityLGNBright = [[0 for j in range(ImageNumPixelColumns)]
for i in range(ImageNumPixelRows)]
plotDensityLGNDark = [[0 for j in range(ImageNumPixelColumns)]
for i in range(ImageNumPixelRows)]
plotDensityOrientationV1 = [[[0 for j in range(numPixelColumns)]
for i in range(numPixelRows)]
for k in range(numOrientations)]
plotDensityOrientationV2 = [[[[0 for j in range(numPixelColumns)]
for i in range(numPixelRows)]
for h in range(numSegmentationLayers)]
for k in range(numOrientations)]
plotDensityBrightnessV4 = [[[0 for j in range(ImageNumPixelColumns)]
for i in range(ImageNumPixelRows)]
'start': 20.0,
'stop': t_stop - 20.0,
'amplitude': 0.6
}
}
neurons = sim.Population(4, sim.GIF_cond_exp(**parameters['neurons']))
electrode = sim.DCSource(**parameters['stimulus'])
electrode.inject_into(neurons)
neurons.record(['v']) #, 'i_eta', 'v_t'])
# === Run the simulation =====================================================
sim.run(t_stop)
data = neurons.get_data().segments[0]
v = data.filter(name="v")[0]
#v_t = data.filter(name="v_t")[0]
#i_eta = data.filter(name="i_eta")[0]
Figure(
Panel(v, ylabel="Membrane potential (mV)", yticks=True, ylim=[-66, -52]),
#Panel(v_t, ylabel="Threshold (mV)",
# yticks=True),
#Panel(i_eta, ylabel="i_eta (nA)", xticks=True,
# xlabel="Time (ms)", yticks=True),
)
plt.show()
def run(self, params):
self._do_record = True
self._network = {}
self._network['timestep'] = 0.1 #ms
self._network['min_delay'] = 0.1 #ms
self._network['run_time'] = 1000
sim.setup(self._network['timestep'],
model_name=self.name,
backend='CUDA')
# Neuron populations
pops = {}
pops['input'] = self.gen_input_pop()
pops['output'] = self.gen_output_pop()
self._network['populations'] = pops
# Projections
projs = {}
projs['inupt to output'] = self.gen_input_to_output_proj()
self._network['projections'] = projs
# Run
log.info('Running sim for {}ms.'.format(self._network['run_time']))
sim.run(self._network['run_time'])
# Collect data
if self._do_record:
log.info('Collect data from all populations:')
for popname, pop in pops.items():
log.info(' -> Saving recorded data for "{}".'.format(popname))
# Voltages
voltagedata = pop.get_data('v')
signal = voltagedata.segments[0].analogsignals[0]
source_ids = signal.annotations['source_ids']
for idx in range(len(source_ids)):
s_id = source_ids[idx]
filename = "%s_%s_%s.dat" % (
pop.label, pop.id_to_index(s_id), signal.name)
vm = signal.transpose()[idx]
tt = np.array([
t * sim.get_time_step() / 1000. for t in range(len(vm))
])
times_vm = np.array([tt, vm / 1000.]).transpose()
np.savetxt(filename, times_vm, delimiter='\t', fmt='%s')
# Spikes
log.info(pop)
spikedata = pop.get_data('spikes')
filename = '{}.spikes'.format(pop.label)
thefile = open(filename, 'w')
for spiketrain in spikedata.segments[0].spiketrains:
source_id = spiketrain.annotations['source_id']
source_index = spiketrain.annotations['source_index']
# #log.info(pp.pprint(vars(spiketrain)))
for t in spiketrain:
thefile.write('%s\t%f\n' %
(source_index, t.magnitude / 1000.))
thefile.close()
# End
sim.end()
sim.setup(**simulator_params[simulator])
import network
# create network
start_netw = time.time()
n = network.Network(sim)
n.setup(sim)
end_netw = time.time()
if sim.rank() == 0 :
print('Creating the network took %g s' % (end_netw - start_netw,))
# simulate
if sim.rank() == 0 :
print("Simulating...")
start_sim = time.time()
t = sim.run(simulator_params[simulator]['sim_duration'])
end_sim = time.time()
if sim.rank() == 0 :
print('Simulation took %g s' % (end_sim - start_sim,))
start_writing = time.time()
for layer in n.pops :
for pop in n.pops[layer] :
io = PyNNTextIO(filename=system_params['output_path'] \
+ "/spikes_" + layer + '_' + pop + '_' + str(sim.rank()) + ".txt")
spikes = n.pops[layer][pop].get_data('spikes', gather=False)
for segment in spikes.segments :
io.write_segment(segment)
if record_v :
io = PyNNTextIO(filename=system_params['output_path'] \
stop=450.0,
amplitude=0.2,
offset=0.1,
frequency=10.0,
phase=180.0),
sim.NoisyCurrentSource(mean=0.5, stdev=0.2, start=50.0, stop=450.0, dt=1.0)
]
for cell, current_source in zip(cells, current_sources):
cell.inject(current_source)
cells.record('v')
# === Run the simulation =====================================================
sim.run(500.0)
# === Save the results, optionally plot a figure =============================
vm = cells.get_data().segments[0].filter(name="v")[0]
sim.end()
from pyNN.utility.plotting import Figure, Panel
from quantities import mV
Figure(Panel(vm,
y_offset=-10 * mV,
xticks=True,
yticks=True,
xlabel="Time (ms)",
ylabel="Membrane potential (mV)",
ylim=(-96, -59)),
sim.EIF_cond_exp_isfa_ista(i_offset=1.0),
label="EIF_cond_exp_isfa_ista")
adapt = sim.Population(1,
sim.IF_cond_exp_gsfa_grr(i_offset=2.0),
label="IF_cond_exp_gsfa_grr")
izh = sim.Population(1, sim.Izhikevich(i_offset=0.01), label="Izhikevich")
all_neurons = cuba_exp + hh + adexp + adapt + izh
all_neurons.record('v')
adexp.record('w')
izh.record('u')
# === Run the simulation =====================================================
sim.run(100.0)
# === Save the results, optionally plot a figure =============================
from pyNN.utility.plotting import Figure, Panel
Figure(
Panel(cuba_exp.get_data().segments[0].filter(name='v')[0],
ylabel="Membrane potential (mV)",
data_labels=[cuba_exp.label],
yticks=True,
ylim=(-66, -48)),
Panel(hh.get_data().segments[0].filter(name='v')[0],
ylabel="Membrane potential (mV)",
data_labels=[hh.label],
yticks=True,
ylim=(-100, 60)),
