def test_poisson_vectorized_values_fixed_and_random_seed():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
G = NeuronGroup(
10, '''l: 1
dv/dt = -v/(10*ms) + 0.1*poisson(l)/ms : 1''')
G.l = arange(10)
mon = StateMonitor(G, 'v', record=True)
# first run
seed(13579)
G.v = 'poisson(l)'
seed()
run(2 * defaultclock.dt)
# second run
seed(13579)
G.v = 'poisson(l)'
seed()
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
# First time step should be identical (same seed)
assert_allclose(first_run_values[:, 0], second_run_values[:, 0])
# Second should be different (random seed)
with pytest.raises(AssertionError):
assert_allclose(first_run_values[:, 1], second_run_values[:, 1])
def test_random_values_fixed_and_random_seed():
G = NeuronGroup(10, 'dv/dt = -v/(10*ms) + 0.1*xi/sqrt(ms) : 1')
mon = StateMonitor(G, 'v', record=True)
# first run
seed(13579)
G.v = 'rand()'
seed()
run(2 * defaultclock.dt)
# second run
seed(13579)
G.v = 'rand()'
seed()
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
# First time step should be identical (same seed)
assert_allclose(first_run_values[:, 0], second_run_values[:, 0])
# Second should be different (random seed)
assert_raises(AssertionError, assert_allclose, first_run_values[:, 1],
second_run_values[:, 1])
def test_multiple_runs_function_change():
inp = TimedArray([1, 2], dt=defaultclock.dt)
group = NeuronGroup(1, 'v = inp(t) : 1')
mon = StateMonitor(group, 'v', record=0)
run(2 * defaultclock.dt)
inp = TimedArray([0, 0, 3, 4], dt=defaultclock.dt)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
assert_equal(mon.v[0], [1, 2, 3, 4])
def test_multiple_runs_constant_change():
const_v = 1
group = NeuronGroup(1, 'v = const_v : 1')
mon = StateMonitor(group, 'v', record=0)
run(defaultclock.dt)
const_v = 2
run(defaultclock.dt)
device.build(direct_call=False, **device.build_options)
assert_equal(mon.v[0], [1, 2])
def test_multiple_runs_report_standalone_3(with_output=False):
set_device('cpp_standalone', build_on_run=False)
group = NeuronGroup(1, 'dv/dt = 1*Hz : 1')
run(1*ms, report='text')
run(1*ms, report='text')
tempdir = tempfile.mkdtemp()
if with_output:
print tempdir
device.build(directory=tempdir, compile=True, run=True,
with_output=with_output)
def test_random_number_generation_with_multiple_runs():
G = NeuronGroup(1000, 'dv/dt = rand() : second')
mon = StateMonitor(G, 'v', record=True)
run(1 * defaultclock.dt)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
assert_raises(AssertionError, assert_equal, mon.v[:, -1], 0)
assert_raises(AssertionError, assert_equal, mon.v[:, -2], mon.v[:, -1])
def test_dt_changes_between_runs():
defaultclock.dt = 0.1 * ms
G = NeuronGroup(1, 'v:1')
mon = StateMonitor(G, 'v', record=True)
run(.5 * ms)
defaultclock.dt = .5 * ms
run(.5 * ms)
defaultclock.dt = 0.1 * ms
run(.5 * ms)
device.build(direct_call=False, **device.build_options)
assert len(mon.t[:]) == 5 + 1 + 5
assert_allclose(
mon.t[:], [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 1., 1.1, 1.2, 1.3, 1.4] * ms)
def test_binomial_values_synapse_dynamics_fixed_and_random_seed():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
my_f = BinomialFunction(100, 0.1, approximate=False)
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
G = NeuronGroup(10, 'z : 1')
S = Synapses(
G, G,
'dv/dt = -v/(10*ms) + 0.1*(my_f() + my_f_approximated())*xi/sqrt(ms) : 1'
)
S.connect()
mon = StateMonitor(S, 'v', record=range(100))
# first run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
# fourth run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
third_run_values = np.array(mon.v[:, [4, 5]])
fourth_run_values = np.array(mon.v[:, [6, 7]])
# First and second run should be different (random seed)
with pytest.raises(AssertionError):
assert_allclose(first_run_values, second_run_values)
# Third and fourth run should be identical (same seed)
assert_allclose(third_run_values, fourth_run_values)
def test_poisson_variable_lambda_values_fixed_and_random_seed():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
G = NeuronGroup(
10, '''l : 1
dv/dt = -v/(10*ms) + 0.1*poisson(l)*xi/sqrt(ms) : 1''')
G.l = arange(10)
mon = StateMonitor(G, 'v', record=True)
# first run
G.v = 0
seed()
run(2 * defaultclock.dt)
# second run
G.v = 0
seed()
run(2 * defaultclock.dt)
# third run
G.v = 0
seed(13579)
run(2 * defaultclock.dt)
# fourth run
G.v = 0
seed(13579)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
third_run_values = np.array(mon.v[:, [4, 5]])
fourth_run_values = np.array(mon.v[:, [6, 7]])
# First and second run should be different (random seed)
with pytest.raises(AssertionError):
assert_allclose(first_run_values, second_run_values)
# Third and fourth run should be identical (same seed)
assert_allclose(third_run_values, fourth_run_values)
def test_binomial_values_synapse_dynamics_fixed_and_random_seed():
my_f = BinomialFunction(100, 0.1, approximate=False)
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
G = NeuronGroup(10, 'z : 1')
S = Synapses(
G, G,
'dv/dt = -v/(10*ms) + 0.1*(my_f() + my_f_approximated())*xi/sqrt(ms) : 1'
)
S.connect()
mon = StateMonitor(S, 'v', record=range(100))
# first run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
# fourth run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
third_run_values = np.array(mon.v[:, [4, 5]])
fourth_run_values = np.array(mon.v[:, [6, 7]])
# First and second run should be different (random seed)
assert_raises(AssertionError, assert_allclose, first_run_values,
second_run_values)
# Third and fourth run should be identical (same seed)
assert_allclose(third_run_values, fourth_run_values)
def example_run(device_name="cuda_standalone",
directory=None,
**build_options):
"""
Run a simple example simulation to test whether Brian2CUDA is correctly set up.
Parameters
----------
device_name : str
What device to use (default: "cuda_standalone").
directory : str ,optional
The output directory to write the project to, any existing files will be
overwritten. If the given directory name is ``None`` (default for this example
run), then a temporary directory will be used.
build_options : dict, optional
Additional options that will be forwarded to the ``device.build`` call,
"""
from brian2.devices.device import device, set_device
from brian2 import ms, NeuronGroup, run
import brian2cuda
import numpy as np
from numpy.testing import assert_allclose
set_device(device_name, build_on_run=False)
N = 100
tau = 10 * ms
G = NeuronGroup(
N,
"dv/dt = -v / tau: 1",
threshold="v > 1",
reset="v = 0",
refractory=5 * ms,
method="linear",
)
G.v = "i / 100."
run(1 * ms)
device.build(direct_call=False, directory=directory, **build_options)
assert_allclose(G.v, np.arange(N) / N * np.exp(-1 * ms / tau))
device.reinit()
device.activate()
print("\nExample run was successful.")
def test_random_values_codeobject_every_tick():
G = NeuronGroup(10, 'dv/dt = -v/(10*ms) + 0.1*xi/sqrt(ms) : 1')
mon = StateMonitor(G, 'v', record=True)
# first run
seed(10124)
G.v = 'rand()'
run(2 * defaultclock.dt)
# second run
seed(10124)
G.v = 'rand()'
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
# First time step should be identical (same seed)
assert_allclose(first_run_values[:, 0], second_run_values[:, 0])
# Second should also be identical (same seed)
assert_allclose(first_run_values[:, 1], second_run_values[:, 1])
def test_multiple_runs_report_standalone_3():
group = NeuronGroup(1, 'dv/dt = 1*Hz : 1')
run(1 * ms, report='text')
run(1 * ms, report='text')
device.build(direct_call=False, **device.build_options)
def test_binomial_values():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
# On Denis' local computer this test blows up all available RAM + SWAP when
# compiling with all threads in parallel. Use half the threads instead.
import socket
if socket.gethostname() == 'selene':
prefs.devices.cpp_standalone.extra_make_args_unix = ['-j4']
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
my_f = BinomialFunction(100, 0.1, approximate=False)
# Test neurongroup every tick objects
G = NeuronGroup(10,
'''dx/dt = my_f_approximated()/ms: 1
dy/dt = my_f()/ms: 1''',
threshold='True')
G.run_regularly('''x = my_f_approximated()
y = my_f()''')
# Test synapses every tick objects (where N is not known at compile time)
syn = Synapses(
G,
G,
model='''
dw/dt = my_f()/ms: 1
dv/dt = my_f_approximated()/ms: 1
''',
on_pre='''
x += w
y += v
'''
# TODO: fails when having binomial here, why?
#on_pre='''
# x += w * my_f()
# y += v * my_f_approximated()
# '''
)
# Test synapses generation, which needs host side binomial
syn.connect(condition='my_f_approximated() < 100')
mon = StateMonitor(G, ['x', 'y'], record=True)
w_mon = StateMonitor(syn, ['w', 'v'], record=np.arange(100))
def init_group_variables(my_f, my_f_approximated):
# Test codeobjects run only once outside the network,
# G.x uses group_variable_set_conditional, G.x[:5] uses group_variable_set
# Synapse objects (N not known at compile time)
syn.w = 'my_f()'
syn.w['i < j'] = 'my_f_approximated()'
syn.v = 'my_f_approximated()'
syn.v['i < j'] = 'my_f()'
# Neurongroup object
G.x = 'my_f_approximated()'
G.x[:5] = 'my_f()'
G.y = 'my_f()'
G.y[:5] = 'my_f_approximated()'
# first run
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# second run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# third run
seed()
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# forth run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
run_values_1 = np.vstack([
mon.x[:, [0, 1]], mon.y[:, [0, 1]], w_mon.w[:, [0, 1]], w_mon.v[:,
[0, 1]]
])
run_values_2 = np.vstack([
mon.x[:, [2, 3]], mon.y[:, [2, 3]], w_mon.w[:, [2, 3]], w_mon.v[:,
[2, 3]]
])
run_values_3 = np.vstack([
mon.x[:, [4, 5]], mon.y[:, [4, 5]], w_mon.w[:, [4, 5]], w_mon.v[:,
[4, 5]]
])
run_values_4 = np.vstack([
mon.x[:, [6, 7]], mon.y[:, [6, 7]], w_mon.w[:, [6, 7]], w_mon.v[:,
[6, 7]]
])
# Two calls to binomial functions should return different numbers in all runs
for n, values in enumerate(
[run_values_1, run_values_2, run_values_3, run_values_4]):
with pytest.raises(AssertionError):
assert_allclose(values[:, 0], values[:, 1])
# 2. and 4. run set the same seed
assert_allclose(run_values_2, run_values_4)
# all other combinations should be different
with pytest.raises(AssertionError):
assert_allclose(run_values_1, run_values_2)
with pytest.raises(AssertionError):
assert_allclose(run_values_1, run_values_3)
with pytest.raises(AssertionError):
assert_allclose(run_values_2, run_values_3)
def test_binomial_values():
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
my_f = BinomialFunction(100, 0.1, approximate=False)
# Test neurongroup every tick objects
G = NeuronGroup(10,
'''dx/dt = my_f_approximated()/ms: 1
dy/dt = my_f()/ms: 1''',
threshold='True')
G.run_regularly('''x = my_f_approximated()
y = my_f()''')
# Test synapses every tick objects (where N is not known at compile time)
syn = Synapses(
G,
G,
model='''
dw/dt = my_f()/ms: 1
dv/dt = my_f_approximated()/ms: 1
''',
on_pre='''
x += w
y += v
'''
# TODO: fails when having binomial here, why?
#on_pre='''
# x += w * my_f()
# y += v * my_f_approximated()
# '''
)
# Test synapses generation, which needs host side binomial
syn.connect(condition='my_f_approximated() < 100')
mon = StateMonitor(G, ['x', 'y'], record=True)
w_mon = StateMonitor(syn, ['w', 'v'], record=np.arange(100))
def init_group_variables(my_f, my_f_approximated):
# Test codeobjects run only once outside the network,
# G.x uses group_variable_set_conditional, G.x[:5] uses group_variable_set
# Synapse objects (N not known at compile time)
syn.w = 'my_f()'
syn.w['i < j'] = 'my_f_approximated()'
syn.v = 'my_f_approximated()'
syn.v['i < j'] = 'my_f()'
# Neurongroup object
G.x = 'my_f_approximated()'
G.x[:5] = 'my_f()'
G.y = 'my_f()'
G.y[:5] = 'my_f_approximated()'
# first run
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# second run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# third run
seed()
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# forth run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
run_values_1 = np.vstack([
mon.x[:, [0, 1]], mon.y[:, [0, 1]], w_mon.w[:, [0, 1]], w_mon.v[:,
[0, 1]]
])
run_values_2 = np.vstack([
mon.x[:, [2, 3]], mon.y[:, [2, 3]], w_mon.w[:, [2, 3]], w_mon.v[:,
[2, 3]]
])
run_values_3 = np.vstack([
mon.x[:, [4, 5]], mon.y[:, [4, 5]], w_mon.w[:, [4, 5]], w_mon.v[:,
[4, 5]]
])
run_values_4 = np.vstack([
mon.x[:, [6, 7]], mon.y[:, [6, 7]], w_mon.w[:, [6, 7]], w_mon.v[:,
[6, 7]]
])
# Two calls to binomial functions should return different numbers in all runs
for n, values in enumerate(
[run_values_1, run_values_2, run_values_3, run_values_4]):
assert_raises(AssertionError, assert_allclose, values[:, 0], values[:,
1])
# 2. and 4. run set the same seed
assert_allclose(run_values_2, run_values_4)
# all other combinations should be different
assert_raises(AssertionError, assert_allclose, run_values_1, run_values_2)
assert_raises(AssertionError, assert_allclose, run_values_1, run_values_3)
assert_raises(AssertionError, assert_allclose, run_values_2, run_values_3)
