for t in segInh.spiketrains[0]:
plt.axvline(t, color='red', linewidth=1.)
for t in segExc.spiketrains[0]:
plt.axvline(t, color='green', linewidth=1.)
max_v = np.max(segment.filter(name='v')[0])
ax0.plot(segment.spiketrains[0],
0.99 * max_v * np.ones_like(segment.spiketrains[0]), '.b')
ax0.plot(segment.filter(name='v')[0], color='blue')
timestep = 1.
runtime = 1000.
sim.setup(timestep)
n_neurons = 1
preExc = sim.Population(n_neurons,
sim.SpikeSourcePoisson(rate=100),
label='input')
preExc.record('spikes')
preInh = sim.Population(n_neurons,
sim.SpikeSourcePoisson(rate=100),
label='input')
preInh.record('spikes')
parameters = {
'v_rest': -65.0, # Resting membrane potential in mV.
'cm': 1.0, # Capacity of the membrane in nF
n_inh = n - n_exc # number of inhibitory cells
if benchmark == "COBA":
celltype = sim.IF_cond_exp
w_exc = Gexc * 1e-3 # We convert conductances to uS
w_inh = Ginh * 1e-3
elif benchmark == "CUBA":
celltype = sim.IF_curr_exp
w_exc = 1e-3 * Gexc * (Erev_exc - v_mean
) # (nA) weight of excitatory synapses
w_inh = 1e-3 * Ginh * (Erev_inh - v_mean) # (nA)
assert w_exc > 0
assert w_inh < 0
# === Build the network ========================================================
node_id = sim.setup(timestep=dt, min_delay=dt, max_delay=2.0, **setup_kwargs)
cell_params = {
'tau_m': tau_m,
'tau_syn_E': tau_exc,
'tau_syn_I': tau_inh,
'v_rest': E_leak,
'v_reset': v_reset,
'v_thresh': v_thresh,
'cm': cm,
'tau_refrac': t_refrac
}
if (benchmark == "COBA"):
cell_params['e_rev_E'] = Erev_exc
cell_params['e_rev_I'] = Erev_inh
import numpy as np
import matplotlib.pyplot as plt
import pynn_genn as sim
def spikes_from_data(data):
spikes = [[] for _ in range(len(data.segments[0].spiketrains))]
for train in data.segments[0].spiketrains:
spikes[int(train.annotations['source_index'])][:] = \
[float(t) for t in train]
return spikes
np.random.seed(1)
sim.setup(timestep=1.0, min_delay=1.0)
max_t = 50 #ms
spikes_per_neuron = int(max_t * 0.1)
n_ssa = 5
n_neurons = [np.random.randint(100, 1000) for _ in range(n_ssa)]
sources = {}
for ssa_id in range(n_ssa):
sources[ssa_id] = {}
spike_times = []
for nid in range(n_neurons[ssa_id]):
n_spikes = int(np.random.choice(spikes_per_neuron))
spikes = np.round(np.random.choice(max_t, size=n_spikes,
in_pop,
connector,
static_synapse,
receptor_type='inhibitory')
# Make inhibitory->excitatory projections
ie_projection = sim.Projection(in_pop,
ex_pop,
connector,
ie_synapse,
receptor_type='inhibitory')
return ex_pop, ie_projection
'''
# Build static network
sim.setup(timestep=1.0)
static_ex_pop,_ = build_network(sim.StaticSynapse(weight=0.0, delay=1.0), 300.0)
# Run for 1s
sim.run(1000)
# Get static spikes and save to disk
static_data = static_ex_pop.get_data()
# Clear simulator state
sim.end()
'''
# Clear simulation state
sim.setup(min_delay=1.0, max_delay=7.0, timestep=1.0)
# 'v_thresh_adapt': -55.0,
# # 'e_rev_I': -e_rev, #mV
# # 'e_rev_E': 0.,#e_rev, #mV
# 'tau_m': 10., # ms
# 'tau_refrac': 0.1, # ms
# 'tau_syn_E': 1.0, # ms
# 'tau_syn_I': 5.0, # ms
# 'tau_thresh': 50.0,
# 'mult_thresh': 1.8,
# 'i_offset': i_offsets,
# }
sim_time = 100.0
timestep = 1.0
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)
import math
import pylab
import pynn_genn as sim
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]")
from LaminartWithSegmentationPyNN import buildNetworkAndConnections
from images2gif import writeGif
# from pyNN.utility import get_simulator
# sim, options = get_simulator()
####################################
### Define parameters down here! ###
####################################
# How time goes
dt = 1.0 # (ms) time step for network updates
stepDuration = 50.0 # (ms) time step for visual input and segmentation signal updates
simTime = 100.0 # (ms)
nTimeSteps = numpy.int(simTime / stepDuration)
sloMoRate = 4.0 # how much the GIFs are slowed vs real time, default is 4.0
sim.setup(timestep=dt, min_delay=1.0, max_delay=10.0) # delays in ms
# General parameters
fileName = "squares 1" # this would be removed if it is in the NRP
input, ImageNumPixelRows, ImageNumPixelColumns = setInput.readAndCropBMP(
fileName, onlyZerosAndOnes=0)
print("Input image dimensions of " + fileName + ": [Rows, Columns] = " +
str([ImageNumPixelRows, ImageNumPixelColumns]))
weightScale = 1.0 # general weight for all connections between neurons
constantInput = 0.5 # input given to the tonic interneuron layer and to the top-down activated segmentation neurons
inputPoisson = 0 # 1 for a poisson spike source input, 0 for a DC current input
cellParams = { # parameters for any neuron in the network
'i_offset': 0.0, # (nA)
'tau_m': 10.0, # (ms)
'tau_syn_E': 2.0, # (ms)
'tau_syn_I': 2.0, # (ms)
'v_rest': -65., # mV
'v_thresh': -55., # mV
'tau_m': 10., # ms
'tau_refrac': 2.0, # ms
'tau_syn_E': 1.0, # ms
'tau_syn_I': 5.0, # ms
}
timestep = 0.1
max_w = 0.01
start_w = max_w / 2.0
min_delay = 0.1
sim.setup(timestep,
min_delay=min_delay,
backend='CUDA'
# backend='SingleThreadedCPU'
)
pre = sim.Population(10, sim.SpikeSourcePoisson(**{'rate': 10}))
post = sim.Population(100, neuron_class(**base_params))
# w = 1.0
w = sim.RandomDistribution('normal', [5.0, 1.0])
synapse = sim.StaticSynapse(weight=w)
prj = sim.Projection(
pre,
post,
sim.FixedProbabilityConnector(0.25),
# prj = sim.Projection(pre, post, sim.AllToAllConnector(),
Since neurons 1 and 2 have deterministic spiking, they should produce the same spike times with
different simulators. Neurons 3 and 4, being stochastic, should spike at different times.
Reference:
Pozzorini, Christian, Skander Mensi, Olivier Hagens, Richard Naud, Christof Koch, and Wulfram Gerstner (2015)
"Automated High-Throughput Characterization of Single Neurons by Means of Simplified Spiking Models."
PLOS Comput Biol 11 (6): e1004275. doi:10.1371/journal.pcbi.1004275.
"""
import matplotlib.pyplot as plt
import pynn_genn as sim
from pyNN.utility.plotting import Figure, Panel
sim.setup(timestep=0.01, min_delay=1.0)
# === Build and instrument the network =======================================
t_stop = 300.0
parameters = {
'neurons': {
'v_rest': -65.0, # Resting membrane potential in mV.
'cm': 1.0, # Capacity of the membrane in nF
'tau_m': 20.0, # Membrane time constant in ms.
'tau_refrac': 4.0, # Duration of refractory period in ms.
'tau_syn_E':
5.0, # Decay time of the excitatory synaptic conductance in ms.
'tau_syn_I':
5.0, # Decay time of the inhibitory synaptic conductance in ms.
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()
from sim_params import simulator_params, system_params
sys.path.append(system_params['backend_path'])
sys.path.append(system_params['pyNN_path'])
from network_params import *
# import logging # TODO! Remove if it runs without this line
import pyNN
import time
from neo.io import PyNNTextIO
import plotting
# prepare simulation
# logging.basicConfig() # TODO! Remove if it runs without this line
#exec('import pyNN.%s as sim' % simulator)
import pynn_genn as sim
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'])
positional arguments:
simulator neuron, nest, brian or another backend simulator
optional arguments:
-h, --help show this help message and exit
--plot-figure Plot the simulation results to a file
"""
import matplotlib.pyplot as plt
import pynn_genn as sim
# === Configure the simulator ================================================
sim.setup()
# === Create four cells and inject current into each one =====================
cells = sim.Population(
4, sim.IF_curr_exp(v_thresh=-55.0, tau_refrac=5.0, tau_m=10.0))
current_sources = [
sim.DCSource(amplitude=0.5, start=50.0, stop=400.0),
sim.StepCurrentSource(times=[50.0, 210.0, 250.0, 410.0],
amplitudes=[0.4, 0.6, -0.2, 0.2]),
sim.ACSource(start=50.0,
stop=450.0,
amplitude=0.2,
offset=0.1,
frequency=10.0,
