def test_refractoriness_threshold():
# Try a quantity, a string evaluating to a quantity an an explicit boolean
# condition -- all should do the same thing
for ref_time in [
10 * ms, '10*ms', '(t-lastspike) <= 10*ms', '(t-lastspike) <= ref',
'ref', 'ref_no_unit*ms'
]:
reinit_devices()
G = NeuronGroup(1,
'''
dv/dt = 199.99*Hz : 1
ref : second
ref_no_unit : 1
''',
threshold='v > 1',
reset='v=0',
refractory=ref_time,
dtype={
'ref': defaultclock.variables['t'].dtype,
'ref_no_unit': defaultclock.variables['t'].dtype
})
G.ref = 10 * ms
G.ref_no_unit = 10
# The neuron should spike after 5ms but then not spike for the next
# 10ms. The state variable should continue to integrate so there should
# be a spike after 15ms
spike_mon = SpikeMonitor(G)
run(16 * ms)
assert_allclose(spike_mon.t, [5, 15] * ms)
def test_refractoriness_variables():
# Try a string evaluating to a quantity an an explicit boolean
# condition -- all should do the same thing
for ref_time in [
'5*ms', '(t-lastspike + 1e-3*dt) < 5*ms',
'time_since_spike + 1e-3*dt < 5*ms', 'ref_subexpression',
'(t-lastspike + 1e-3*dt) <= ref', 'ref', 'ref_no_unit*ms'
]:
reinit_devices()
G = NeuronGroup(1,
'''
dv/dt = 99.999*Hz : 1 (unless refractory)
dw/dt = 99.999*Hz : 1
ref : second
ref_no_unit : 1
time_since_spike = (t - lastspike) +1e-3*dt : second
ref_subexpression = (t - lastspike + 1e-3*dt) < ref : boolean
''',
threshold='v>1',
reset='v=0;w=0',
refractory=ref_time,
dtype={
'ref': defaultclock.variables['t'].dtype,
'ref_no_unit': defaultclock.variables['t'].dtype,
'lastspike': defaultclock.variables['t'].dtype,
'time_since_spike':
defaultclock.variables['t'].dtype
})
G.ref = 5 * ms
G.ref_no_unit = 5
# It should take 10ms to reach the threshold, then v should stay at 0
# for 5ms, while w continues to increase
mon = StateMonitor(G, ['v', 'w'], record=True, when='end')
run(20 * ms)
try:
# No difference before the spike
assert_allclose(mon[0].v[:timestep(10 * ms, defaultclock.dt)],
mon[0].w[:timestep(10 * ms, defaultclock.dt)])
# v is not updated during refractoriness
in_refractoriness = mon[0].v[timestep(10 * ms, defaultclock.dt):
timestep(15 * ms, defaultclock.dt)]
assert_allclose(in_refractoriness,
np.zeros_like(in_refractoriness))
# w should evolve as before
assert_allclose(
mon[0].w[:timestep(5 * ms, defaultclock.dt)],
mon[0].w[timestep(10 * ms, defaultclock.dt) +
1:timestep(15 * ms, defaultclock.dt) + 1])
assert np.all(
mon[0].w[timestep(10 * ms, defaultclock.dt) +
1:timestep(15 * ms, defaultclock.dt) + 1] > 0)
# After refractoriness, v should increase again
assert np.all(
mon[0].v[timestep(15 * ms, defaultclock.dt
):timestep(20 * ms, defaultclock.dt)] > 0)
except AssertionError as ex:
raise
raise AssertionError(
'Assertion failed when using %r as refractory argument:\n%s' %
(ref_time, ex))
def test_sorted_indices_statemonitor():
previous_device = get_device()
results = {}
n_cells = 5
n_recorded = 10
delay = np.arange(n_cells) * defaultclock.dt
for devicename in ['cpp_standalone', 'cuda_standalone']:
set_device(devicename, build_on_run=False, with_output=False)
Synapses.__instances__().clear()
reinit_devices()
P = NeuronGroup(n_cells, model='', threshold='True')
S = Synapses(P, P, model='''w : 1''', on_pre='''w += 1''')
S.connect(j='i')
S.pre.delay = delay
state_mon = StateMonitor(S, 'w', record=range(n_recorded))
run(defaultclock.dt * (n_cells + 1))
device.build(directory=None, with_output=False)
results[devicename] = state_mon.w.astype(int)
assert_allclose(results['cpp_standalone'].sum(axis=0),
results['cuda_standalone'].sum(axis=0))
assert_allclose(results['cpp_standalone'], results['cuda_standalone'])
reset_device(previous_device)
def test_refractoriness_variables():
# Try a string evaluating to a quantity an an explicit boolean
# condition -- all should do the same thing
for ref_time in [
'5*ms', '(t-lastspike) <= 5*ms', 'time_since_spike <= 5*ms',
'ref_subexpression', '(t-lastspike) <= ref', 'ref',
'ref_no_unit*ms'
]:
reinit_devices()
G = NeuronGroup(1,
'''
dv/dt = 100*Hz : 1 (unless refractory)
dw/dt = 100*Hz : 1
ref : second
ref_no_unit : 1
time_since_spike = t - lastspike : second
ref_subexpression = (t - lastspike) <= ref : boolean
''',
threshold='v>1',
reset='v=0;w=0',
refractory=ref_time)
G.ref = 5 * ms
G.ref_no_unit = 5
# It should take 10ms to reach the threshold, then v should stay at 0
# for 5ms, while w continues to increase
mon = StateMonitor(G, ['v', 'w'], record=True, when='end')
run(20 * ms)
try:
# No difference before the spike
assert_equal(mon[0].v[mon.t < 10 * ms], mon[0].w[mon.t < 10 * ms])
# v is not updated during refractoriness
in_refractoriness = mon[0].v[(mon.t >= 10 * ms)
& (mon.t < 15 * ms)]
assert_equal(in_refractoriness, np.zeros_like(in_refractoriness))
# w should evolve as before
assert_equal(mon[0].w[mon.t < 5 * ms],
mon[0].w[(mon.t >= 10 * ms) & (mon.t < 15 * ms)])
assert np.all(mon[0].w[(mon.t >= 10 * ms) & (mon.t < 15 * ms)] > 0)
# After refractoriness, v should increase again
assert np.all(mon[0].v[(mon.t >= 15 * ms) & (mon.t < 20 * ms)] > 0)
except AssertionError as ex:
raise AssertionError(
'Assertion failed when using %r as refractory argument:\n%s' %
(ref_time, ex))
def test_refractoriness_threshold():
# Try a quantity, a string evaluating to a quantity an an explicit boolean
# condition -- all should do the same thing
for ref_time in [10*ms, '10*ms', '(t-lastspike) <= 10*ms',
'(t-lastspike) <= ref', 'ref', 'ref_no_unit*ms']:
reinit_devices()
G = NeuronGroup(1, '''
dv/dt = 200*Hz : 1
ref : second
ref_no_unit : 1
''', threshold='v > 1',
reset='v=0', refractory=ref_time)
G.ref = 10*ms
G.ref_no_unit = 10
# The neuron should spike after 5ms but then not spike for the next
# 10ms. The state variable should continue to integrate so there should
# be a spike after 15ms
spike_mon = SpikeMonitor(G)
run(16*ms)
assert_allclose(spike_mon.t, [4.9, 15] * ms)
def generate_results(num_repeats):
results = {}
for name in ['CUBA', 'COBA']:
for target in ['numpy', 'cython', 'weave']:
for dtype in [float32, float64]:
prefs.codegen.target = target
prefs.core.default_float_dtype = dtype
times = [run_benchmark(name) for repeat in range(num_repeats)]
results[name, target, dtype.__name__] = amin(times)
for name in ['CUBA', 'COBA']:
for dtype in [float32, float64]:
times = []
for _ in range(num_repeats):
reset_device()
reinit_devices()
set_device('cpp_standalone', directory=None, with_output=False)
prefs.core.default_float_dtype = dtype
times.append(run_benchmark(name))
results[name, 'cpp_standalone', dtype.__name__] = amin(times)
return results
def test_refractoriness_variables():
# Try a string evaluating to a quantity an an explicit boolean
# condition -- all should do the same thing
for ref_time in ['5*ms', '(t-lastspike) <= 5*ms',
'time_since_spike <= 5*ms', 'ref_subexpression',
'(t-lastspike) <= ref', 'ref', 'ref_no_unit*ms']:
reinit_devices()
G = NeuronGroup(1, '''
dv/dt = 100*Hz : 1 (unless refractory)
dw/dt = 100*Hz : 1
ref : second
ref_no_unit : 1
time_since_spike = t - lastspike : second
ref_subexpression = (t - lastspike) <= ref : boolean
''',
threshold='v>1', reset='v=0;w=0',
refractory=ref_time)
G.ref = 5*ms
G.ref_no_unit = 5
# It should take 10ms to reach the threshold, then v should stay at 0
# for 5ms, while w continues to increase
mon = StateMonitor(G, ['v', 'w'], record=True, when='end')
run(20*ms)
try:
# No difference before the spike
assert_equal(mon[0].v[mon.t < 10*ms], mon[0].w[mon.t < 10*ms])
# v is not updated during refractoriness
in_refractoriness = mon[0].v[(mon.t >= 10*ms) & (mon.t <15*ms)]
assert_equal(in_refractoriness, np.zeros_like(in_refractoriness))
# w should evolve as before
assert_equal(mon[0].w[mon.t < 5*ms], mon[0].w[(mon.t >= 10*ms) & (mon.t <15*ms)])
assert np.all(mon[0].w[(mon.t >= 10*ms) & (mon.t <15*ms)] > 0)
# After refractoriness, v should increase again
assert np.all(mon[0].v[(mon.t >= 15*ms) & (mon.t <20*ms)] > 0)
except AssertionError as ex:
raise AssertionError('Assertion failed when using %r as refractory argument:\n%s' % (ref_time, ex))
net = Network(collect())
assert_raises(NotImplementedError, lambda: net.run(0 * ms))
defaultclock.dt = old_dt
@attr('standalone-compatible')
@with_setup(teardown=reinit_devices)
def test_poissoninput_refractory():
eqs = '''
dv/dt = 0/second : 1 (unless refractory)
'''
G = NeuronGroup(10,
eqs,
reset='v=0',
threshold='v>4.5',
refractory=5 * defaultclock.dt)
# Will increase the value by 1.0 at each time step
P = PoissonInput(G, 'v', 1, 1 / defaultclock.dt, weight=1.0)
mon = StateMonitor(G, 'v', record=5)
run(10 * defaultclock.dt)
expected = np.arange(10, dtype=np.float)
expected[6 - int(schedule_propagation_offset() / defaultclock.dt):] = 0
assert_allclose(mon[5].v[:], expected)
if __name__ == '__main__':
test_poissoninput()
reinit_devices()
test_poissoninput_errors()
test_poissoninput_refractory()
def test_openmp_consistency():
previous_device = get_device()
n_cells = 100
n_recorded = 10
numpy.random.seed(42)
taum = 20 * ms
taus = 5 * ms
Vt = -50 * mV
Vr = -60 * mV
El = -49 * mV
fac = (60 * 0.27 / 10)
gmax = 20*fac
dApre = .01
taupre = 20 * ms
taupost = taupre
dApost = -dApre * taupre / taupost * 1.05
dApost *= 0.1*gmax
dApre *= 0.1*gmax
connectivity = numpy.random.randn(n_cells, n_cells)
sources = numpy.random.random_integers(0, n_cells-1, 10*n_cells)
# Only use one spike per time step (to rule out that a single source neuron
# has more than one spike in a time step)
times = numpy.random.choice(numpy.arange(10*n_cells), 10*n_cells,
replace=False)*ms
v_init = Vr + numpy.random.rand(n_cells) * (Vt - Vr)
eqs = Equations('''
dv/dt = (g-(v-El))/taum : volt
dg/dt = -g/taus : volt
''')
results = {}
for (n_threads, devicename) in [(0, 'runtime'),
(0, 'cpp_standalone'),
(1, 'cpp_standalone'),
(2, 'cpp_standalone'),
(3, 'cpp_standalone'),
(4, 'cpp_standalone')]:
set_device(devicename, build_on_run=False, with_output=False)
Synapses.__instances__().clear()
if devicename == 'cpp_standalone':
reinit_devices()
prefs.devices.cpp_standalone.openmp_threads = n_threads
P = NeuronGroup(n_cells, model=eqs, threshold='v>Vt', reset='v=Vr', refractory=5 * ms)
Q = SpikeGeneratorGroup(n_cells, sources, times)
P.v = v_init
P.g = 0 * mV
S = Synapses(P, P,
model = '''dApre/dt=-Apre/taupre : 1 (event-driven)
dApost/dt=-Apost/taupost : 1 (event-driven)
w : 1''',
pre = '''g += w*mV
Apre += dApre
w = w + Apost''',
post = '''Apost += dApost
w = w + Apre''')
S.connect()
S.w = fac*connectivity.flatten()
T = Synapses(Q, P, model = "w : 1", on_pre="g += w*mV")
T.connect(j='i')
T.w = 10*fac
spike_mon = SpikeMonitor(P)
rate_mon = PopulationRateMonitor(P)
state_mon = StateMonitor(S, 'w', record=range(n_recorded), dt=0.1*second)
v_mon = StateMonitor(P, 'v', record=range(n_recorded))
run(0.2 * second, report='text')
if devicename == 'cpp_standalone':
device.build(directory=None, with_output=False)
results[n_threads, devicename] = {}
results[n_threads, devicename]['w'] = state_mon.w
results[n_threads, devicename]['v'] = v_mon.v
results[n_threads, devicename]['s'] = spike_mon.num_spikes
results[n_threads, devicename]['r'] = rate_mon.rate[:]
for key1, key2 in [((0, 'runtime'), (0, 'cpp_standalone')),
((1, 'cpp_standalone'), (0, 'cpp_standalone')),
((2, 'cpp_standalone'), (0, 'cpp_standalone')),
((3, 'cpp_standalone'), (0, 'cpp_standalone')),
((4, 'cpp_standalone'), (0, 'cpp_standalone'))
]:
assert_allclose(results[key1]['w'], results[key2]['w'])
assert_allclose(results[key1]['v'], results[key2]['v'])
assert_allclose(results[key1]['r'], results[key2]['r'])
assert_allclose(results[key1]['s'], results[key2]['s'])
reset_device(previous_device)
def simple_model(N,
params,
record=None,
update_progress=None,
fm=None,
minimum_initial_time=100 * ms,
use_standalone_openmp=False):
if use_standalone_openmp:
prefs.devices.cpp_standalone.openmp_threads = multiprocessing.cpu_count(
) / 2 # assume hyperthreading
set_device('cpp_standalone', with_output=True)
seed(3402348923) # for reproducibility
if fm is None:
fm = dietz_fm
orig_fm = fm
min_tauihc = 0.1 * ms
eqs = '''
carrier = clip(cos(2*pi*fc*t), 0, Inf) : 1
A_raw = (carrier*gain*0.5*(1-cos(2*pi*fm*t)))**gamma : 1
dA_filt/dt = (A_raw-A)/(int(tauihc<min_tauihc)*1*second+tauihc) : 1
A = A_raw*int(tauihc<min_tauihc)+A_filt*int(tauihc>=min_tauihc) : 1
dQ/dt = -k*Q*A+R*(1-Q) : 1
AQ = A*Q : 1
dAe/dt = (AQ-Ae)/taue : 1
dAi/dt = (AQ-Ai)/taui : 1
out = clip(Ae-beta*Ai, 0, Inf) : 1
gain = 10**(level/20.) : 1
R = (1-alpha)/taua : Hz
k = alpha/taua : Hz
fc = fc_Hz*Hz : Hz
fc_Hz : 1
fm : Hz
tauihc = tauihc_ms*ms : second
taue = taue_ms*ms : second
taui = taui_ms*ms : second
taua = taua_ms*ms : second
tauihc_ms : 1
taue_ms : 1
taui_ms : 1
taua_ms : 1
alpha : 1
beta : 1
gamma : 1
level : 1
# Accumulation variables
start_time : second
end_time : second
do_accumulate = 1.0*int(t>=start_time and t<end_time) : 1
accum_sum_out : 1
accum_sum_out_rising : 1
accum_sum_out_falling : 1
accum_argmax_out : second
accum_max_out : 1
accum_weighted_sum_cos_phase : 1
accum_weighted_sum_sin_phase : 1
'''
G = NeuronGroup(N * len(fm), eqs, method='euler', dt=0.1 * ms)
rr = G.run_regularly('''
accum_sum_out += out*do_accumulate
phase = (2*pi*fm*t)%(2*pi)
accum_sum_out_rising += out*int(phase<pi)*do_accumulate
accum_sum_out_falling += out*int(phase>=pi)*do_accumulate
accum_weighted_sum_cos_phase += out*cos(phase)*do_accumulate
accum_weighted_sum_sin_phase += out*sin(phase)*do_accumulate
is_larger = out>accum_max_out and do_accumulate>0
accum_max_out = int(not is_larger)*accum_max_out+int(is_larger)*out
accum_argmax_out = int(not is_larger)*accum_argmax_out+int(is_larger)*t
''',
when='end')
params = params.copy()
for k, v in params.items():
if isinstance(v, tuple) and len(v) == 2:
low, high = v
params[k] = v = rand(N) * (high - low) + low
params2d = params.copy()
for k, v in params2d.items():
if isinstance(v, ndarray) and v.size > 1:
v = reshape(v, v.size)
fm, v = meshgrid(orig_fm,
v) # fm and v have shape (N, len(dietz_fm))
fm.shape = fm.size
v.shape = v.size
params2d[k] = v
params2d['fm'] = fm
G.set_states(params2d)
G.tauihc_ms['tauihc_ms<min_tauihc/ms'] = 0
G.Q = 1
net = Network(G, rr)
# Calculate how long to run the simulation
period = 1 / fm
num_initial_cycles = ceil(
minimum_initial_time /
period) # at least one period and at least that time
start_time = num_initial_cycles * period
end_time = (num_initial_cycles + 1) * period
duration = amax(end_time)
G.start_time = start_time
G.end_time = end_time
# Run the simulation
if isinstance(update_progress, basestring):
report_period = 10 * second
else:
report_period = 1 * second
if record:
M = StateMonitor(G, record, record=True)
net.add(M)
net.run(duration, report=update_progress, report_period=report_period)
G.accum_sum_out['accum_sum_out<1e-10'] = 1
for name in [
'accum_sum_out_rising', 'accum_sum_out_falling',
'accum_argmax_out', 'accum_max_out',
'accum_weighted_sum_cos_phase', 'accum_weighted_sum_sin_phase'
]:
if name == 'accum_argmax_out':
u = second
else:
u = 1
getattr(G, name)['accum_sum_out>1e10'] = 0 * u
G.accum_sum_out['accum_sum_out>1e10'] = 1
c = G.accum_weighted_sum_cos_phase[:]
s = G.accum_weighted_sum_sin_phase[:]
weighted_phase = (angle(c + 1j * s) + 2 * pi) % (2 * pi)
vs = sqrt(c**2 + s**2) / G.accum_sum_out[:]
mean_fr = G.accum_sum_out[:] / ((end_time - start_time) / G.dt)
onsettiness = 0.5 * (1 + (G.accum_sum_out_rising[:] -
G.accum_sum_out_falling[:]) / G.accum_sum_out[:])
res = Results(
accum_argmax_out=G.accum_argmax_out[:],
accum_max_out=G.accum_max_out[:],
weighted_phase=weighted_phase,
vs=vs,
mean_fr=mean_fr,
onsettiness=onsettiness,
params=params,
start_time=start_time,
end_time=end_time,
)
if record:
for name in record:
v = getattr(M, name)[:, :]
v.shape = (N, len(dietz_fm), -1)
setattr(res, name, v)
res.t = M.t[:]
if use_standalone_openmp:
reset_device()
reinit_devices()
return res
test_magic_collect,
test_progress_report,
test_progress_report_incorrect,
test_multiple_runs_report_standalone,
test_multiple_runs_report_standalone_2,
test_multiple_runs_report_standalone_3,
test_multiple_runs_report_standalone_incorrect,
test_store_restore,
test_store_restore_to_file,
test_store_restore_to_file_new_objects,
test_store_restore_to_file_differing_nets,
test_store_restore_magic,
test_store_restore_magic_to_file,
test_defaultclock_dt_changes,
test_dt_changes_between_runs,
test_dt_restore,
test_continuation,
test_get_set_states,
test_multiple_runs_defaultclock,
test_multiple_runs_defaultclock_incorrect,
test_profile,
test_profile_ipython_html,
test_magic_scope,
test_runtime_rounding,
test_small_runs,
test_long_run_dt_change,
]:
set_device(all_devices['runtime'])
t()
reinit_devices()
def fin():
reinit_devices()
set_device('runtime')
def fin():
reinit_devices()
def test_openmp_consistency(with_output=False):
previous_device = get_device()
n_cells = 100
n_recorded = 10
numpy.random.seed(42)
taum = 20 * ms
taus = 5 * ms
Vt = -50 * mV
Vr = -60 * mV
El = -49 * mV
fac = (60 * 0.27 / 10)
gmax = 20*fac
dApre = .01
taupre = 20 * ms
taupost = taupre
dApost = -dApre * taupre / taupost * 1.05
dApost *= 0.1*gmax
dApre *= 0.1*gmax
connectivity = numpy.random.randn(n_cells, n_cells)
sources = numpy.random.random_integers(0, n_cells-1, 10*n_cells)
# Only use one spike per time step (to rule out that a single source neuron
# has more than one spike in a time step)
times = numpy.random.choice(numpy.arange(10*n_cells), 10*n_cells,
replace=False)*ms
v_init = Vr + numpy.random.rand(n_cells) * (Vt - Vr)
eqs = Equations('''
dv/dt = (g-(v-El))/taum : volt
dg/dt = -g/taus : volt
''')
results = {}
for (n_threads, devicename) in [(0, 'runtime'),
(0, 'cpp_standalone'),
(1, 'cpp_standalone'),
(2, 'cpp_standalone'),
(3, 'cpp_standalone'),
(4, 'cpp_standalone')]:
set_device(devicename, build_on_run=False, with_output=False)
Synapses.__instances__().clear()
if devicename=='cpp_standalone':
reinit_devices()
prefs.devices.cpp_standalone.openmp_threads = n_threads
P = NeuronGroup(n_cells, model=eqs, threshold='v>Vt', reset='v=Vr', refractory=5 * ms)
Q = SpikeGeneratorGroup(n_cells, sources, times)
P.v = v_init
P.g = 0 * mV
S = Synapses(P, P,
model = '''dApre/dt=-Apre/taupre : 1 (event-driven)
dApost/dt=-Apost/taupost : 1 (event-driven)
w : 1''',
pre = '''g += w*mV
Apre += dApre
w = w + Apost''',
post = '''Apost += dApost
w = w + Apre''')
S.connect()
S.w = fac*connectivity.flatten()
T = Synapses(Q, P, model = "w : 1", on_pre="g += w*mV")
T.connect(j='i')
T.w = 10*fac
spike_mon = SpikeMonitor(P)
rate_mon = PopulationRateMonitor(P)
state_mon = StateMonitor(S, 'w', record=range(n_recorded), dt=0.1*second)
v_mon = StateMonitor(P, 'v', record=range(n_recorded))
run(0.2 * second, report='text')
if devicename=='cpp_standalone':
tempdir = tempfile.mkdtemp()
if with_output:
print tempdir
device.build(directory=tempdir, compile=True,
run=True, with_output=with_output)
results[n_threads, devicename] = {}
results[n_threads, devicename]['w'] = state_mon.w
results[n_threads, devicename]['v'] = v_mon.v
results[n_threads, devicename]['s'] = spike_mon.num_spikes
results[n_threads, devicename]['r'] = rate_mon.rate[:]
for key1, key2 in [((0, 'runtime'), (0, 'cpp_standalone')),
((1, 'cpp_standalone'), (0, 'cpp_standalone')),
((2, 'cpp_standalone'), (0, 'cpp_standalone')),
((3, 'cpp_standalone'), (0, 'cpp_standalone')),
((4, 'cpp_standalone'), (0, 'cpp_standalone'))
]:
assert_allclose(results[key1]['w'], results[key2]['w'])
assert_allclose(results[key1]['v'], results[key2]['v'])
assert_allclose(results[key1]['r'], results[key2]['r'])
assert_allclose(results[key1]['s'], results[key2]['s'])
reset_device(previous_device)
