def test_plot_monitors():
set_device('runtime')
group = NeuronGroup(10, 'dv/dt = -v/(10*ms) : volt', threshold='False',
method='linear')
group.v = np.linspace(0, 1, 10)*mV
spike_mon = SpikeMonitor(group)
rate_mon = PopulationRateMonitor(group)
state_mon = StateMonitor(group, 'v', record=[3, 5])
run(10*ms)
# Just checking whether the plotting does not fail with an error and that
# it retuns an Axis object as promised
ax = brian_plot(spike_mon)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_raster(spike_mon.i, spike_mon.t)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = brian_plot(rate_mon)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_rate(rate_mon.t, rate_mon.rate)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = brian_plot(state_mon)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_state(state_mon.t, state_mon.v.T)
assert isinstance(ax, matplotlib.axes.Axes)
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.prefs['core.default_float_dtype'] = brian2.float32
brian2.prefs['devices.genn.synapse_span_type'] = 'PRESYNAPTIC'
brian2.prefs['devices.genn.kernel_timing'] = True
brian2.prefs._backup()
brian2.set_device('genn')
def runtest(self):
import matplotlib as _mpl
_mpl.use('Agg')
import numpy as np
from brian2 import prefs
from brian2.utils.filetools import ensure_directory_of_file
prefs.codegen.target = self.codegen_target
prefs.core.default_float_dtype = self.dtype
# Move to the file's directory for the run, so that it can do relative
# imports and load files (e.g. figure style files)
curdir = os.getcwd()
os.chdir(os.path.dirname(self.filename))
sys.path.append(os.path.dirname(self.filename))
try:
runpy.run_path(self.filename, run_name='__main__')
if self.codegen_target == 'cython' and self.dtype == np.float64:
for fignum in _mpl.pyplot.get_fignums():
fname = os.path.relpath(self.filename, self.example_dir)
fname = fname.replace('/', '.').replace('\\\\', '.')
fname = fname.replace('.py', '.%d.png' % fignum)
fname = os.path.abspath(
os.path.join(
self.example_dir,
'../docs_sphinx/resources/examples_images/',
fname))
ensure_directory_of_file(fname)
_mpl.pyplot.figure(fignum).savefig(fname)
finally:
_mpl.pyplot.close('all')
os.chdir(curdir)
sys.path.remove(os.path.dirname(self.filename))
device.reinit()
set_device('runtime')
def test_ExportDevice_options():
"""
Test the run and build options of ExportDevice
"""
# test1
set_device('exporter')
grp = NeuronGroup(10, 'eqn = 1:1', method='exact')
run(100 * ms)
_ = StateMonitor(grp, 'eqn', record=False)
with pytest.raises(RuntimeError):
run(100 * ms)
# test2
device.reinit()
with pytest.raises(RuntimeError):
device.build()
# test3
start_scope()
net = Network()
set_device('exporter', build_on_run=False)
grp = NeuronGroup(10, 'eqn = 1:1', method='exact')
net.add(grp)
net.run(10 * ms)
pogrp = PoissonGroup(10, rates=10 * Hz)
net.add(pogrp)
net.run(10 * ms)
mon = StateMonitor(grp, 'eqn', record=False)
net.add(mon)
net.run(10 * ms)
device.build()
device.reinit()
def test_synapse_init():
# check initializations validity for synapse variables
start_scope()
set_device('exporter')
eqn = 'dv/dt = -v/tau :1'
tau = 1 * ms
w = 1
P = NeuronGroup(5, eqn, method='euler', threshold='v>0.8')
Q = NeuronGroup(10, eqn, method='euler', threshold='v>0.9')
S = Synapses(P, Q, 'g :1', on_pre='v += w')
S.connect()
# allowable
S.g['i>10'] = 10
S.g[-1] = -1
S.g[10000] = 'rand() + w + w'
mon = StateMonitor(S, 'g', record=[0, 1])
run(1 * ms)
# not allowable
with pytest.raises(NotImplementedError):
S.g[0:1000] = -1
run(0.5 * ms)
with pytest.raises(NotImplementedError):
S.g[0:1] = 'rand() + 10'
run(0.25 * ms)
with pytest.raises(NotImplementedError):
_ = StateMonitor(S, 'g', S.g[0:10])
device.reinit()
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.prefs._backup()
brian2.set_device('genn')
# use another gcc version with GeNN
os.environ[
'PATH'] = '~/defapps/genn/' + os.pathsep + os.environ['PATH']
def test_plot_morphology():
set_device('runtime')
# Only testing 2D plotting for now
morpho = Soma(diameter=30 * um)
morpho.axon = Cylinder(diameter=10 * um, n=10, length=100 * um)
morpho.dend = Section(diameter=np.linspace(10, 1, 11) * um,
n=10,
length=np.ones(10) * 5 * um)
morpho = morpho.generate_coordinates()
# Just checking whether the plotting does not fail with an error and that
# it retuns an Axis object as promised
ax = brian_plot(morpho)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_dendrogram(morpho)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_morphology(morpho)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_morphology(morpho, show_diameter=True)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_morphology(morpho, show_compartments=True)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_morphology(morpho, show_diameter=True, show_compartments=True)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
def simulation1(flag_device=False, path="", rec_idx=idx_to_record):
if flag_device:
set_device('neuroml2', filename=LEMS_OUTPUT_FILENAME)
n = 100
duration = 1 * second
tau = 10 * ms
eqs = '''
dv/dt = (v0 - v) / tau : volt (unless refractory)
v0 : volt
'''
group = NeuronGroup(n,
eqs,
threshold='v > 10*mV',
reset='v = 0*mV',
refractory=5 * ms,
method='linear')
group.v = 0 * mV
group.v0 = '20*mV * i / (N-1)'
statemonitor = StateMonitor(group, 'v', record=rec_idx)
spikemonitor = SpikeMonitor(group, record=rec_idx)
run(duration)
if not flag_device:
recvec = []
for ri in rec_idx:
recvec.append(statemonitor[ri].v)
recvec = np.asarray(recvec)
return recvec
else:
return None
def sim_sweep(num, plot=False):
b2.set_device('cpp_standalone', directory='sweep_{}'.format(num))
data = ds.get_sweep(num)
result = sim_Brian2_AllenSDK(neuron_config, data)
t, V, V_0, = result
#Compute errors where AllenSDK trace is not NaN
errors = []
w = np.where(~np.isnan(V_0))
err = MSE(V_0[w], V[w], squared=False)
errors += [err]
print("info: RMSE [V] = {}".format(err))
if plot:
fig = plt.figure()
fig.suptitle('Stimulus')
plt.plot(t, data['stimulus'])
fig = plt.figure()
fig.suptitle('V')
plt.plot(t, V)
plt.plot(t, V_0)
plt.show()
b2.device.delete(force=True)
b2.device.reinit()
return tuple(errors)
def calculate_input_seqs(self):
"""
Calculating input sequence based on the video input.
"""
b2.set_device('cpp_standalone',
directory=os.path.join(
self.output_folder,
'Input_cpp_run' + self.output_file_suffix))
# inputdt = b2.defaultclock.dt
spikemons = []
n0 = len(self.i_patterns[0].T)
frames = self.frames
factor = self.factor
# tmp_group = b2.NeuronGroup(n0, 'rate = frames(t,i)*factor : Hz', threshold='b2.rand()<rate*dt')
tmp_group = b2.NeuronGroup(n0,
'rate = frames(t,i)*factor : Hz',
threshold='rand()<rate*dt')
tmp_network = b2.Network()
tmp_network.add(tmp_group)
tmp_mon = b2.SpikeMonitor(tmp_group)
tmp_network.add(tmp_mon)
spikemons.append(tmp_mon)
if self.BaseLine == 0 * second:
tmp_network.run(self.duration, report='text')
else:
tmp_network.run(self.BaseLine)
tmp_network.run(self.duration - self.BaseLine)
self.save_input_sequence(
spikemons,
os.path.join(self.output_folder,
'input' + self.output_file_suffix))
shutil.rmtree(
os.path.join(self.output_folder,
'Input_cpp_run' + self.output_file_suffix))
def before_run(self):
brian2.prefs.reset_to_defaults()
if self.single_precision:
brian2.prefs['core.default_float_dtype'] = brian2.float32
brian2.prefs._backup()
brian2.set_device('cpp_standalone',
build_on_run=False,
profile=self.profile)
def simulate_FSI_cell(par, par_sim):
pid = os.getpid()
b2.set_device('cpp_standalone', directory=join(
"output", f"standalone-{pid}"))
b2.get_device().reinit()
b2.get_device().activate(
directory=join("output", f"standalone-{pid}"))
num = par['num']
input_current = par['i_ext']
eqs = '''
Iapp = input_current(t, i): amp
m_inf = 1.0/(1.0+exp(-(vf+24*mV)/(11.5*mV))):1
h_inf = 1.0/(1.0+exp(-(vf+58.3*mV)/(-6.7*mV))):1
n_inf = 1.0/(1.0+exp(-(vf+12.4*mV)/(6.8*mV))):1
a_inf = 1.0/(1.0+exp(-(vf+50*mV)/(20.*mV))):1
b_inf = 1.0/(1.0+exp(-(vf+70*mV)/(-6.*mV))):1
tau_h=0.5*ms+14.0*ms/(1.0+exp(-(vf+60*mV)/(-12.*mV))):second
tau_n=(0.087*ms+11.4*ms/(1.0+exp(-(vf+14.6*mV)/(-8.6*mV))))
*(0.087+11.4/(1.0+exp(-(vf-1.3*mV)/(18.7*mV)))) :second
membrain_Im = -gNa*m_inf**3 *h*(vf-50*mV)
-gK*(n**power_n)*(vf+90*mV)
-gL*(vf+70*mV)-gA*a**3*b*(vf+90*mV)+Iapp:amp
dh/dt=(h_inf-h)/tau_h :1
dn/dt=(n_inf-n)/tau_n :1
da/dt=(a_inf-a)/(2.*ms) :1
db/dt=(b_inf-b)/(150.*ms) :1
dvf/dt=membrain_Im/Cm :volt
'''
neuron = b2.NeuronGroup(num,
eqs,
method=par_sim['integration_method'],
dt=par_sim['dt'],
threshold='vf>-20*mV',
refractory='vf>-20*mV',
namespace=par,
)
neuron.vf = par['v0']
neuron.h = "h_inf"
neuron.n = "n_inf"
neuron.a = "a_inf"
neuron.b = "b_inf"
st_mon = b2.StateMonitor(neuron, ["vf", "Iapp"], record=True)
net = b2.Network(neuron)
net.add(st_mon)
net.run(par_sim['simulation_time'])
return st_mon
def test_simple_syntax():
"""
Simple example
"""
set_device('markdown')
N = 10
tau = 10 * ms
v_th = 0.9 * volt
v_rest = -79 * mV
eqn = 'dv/dt = (v_th - v)/tau :volt'
refractory = 'randn() * tau / N'
rates = 'rand() * 5 * Hz'
group = NeuronGroup(N, eqn, method='euler', threshold='v > v_th',
reset='v = v_rest; v = rand() * v_rest',
refractory=refractory,
events={'custom': 'v > v_th + 10 * mV',
'custom_1': 'v > v_th - 10 * mV'})
group.run_on_event('custom', 'v = v_rest')
group.run_on_event('custom_1', 'v = v_rest - 0.001 * mV')
spikegen = SpikeGeneratorGroup(N, [0, 1, 2], [1, 2, 3] * ms,
period=5 * ms)
po_grp = PoissonGroup(N - 1, rates=rates)
syn = Synapses(spikegen, group, model='w :volt',
on_pre='v = rand() * w + v_th; v = rand() * w',
on_post='v = rand() * w + v_rest; v = rand() * w',
delay=tau, method='euler')
group.v[:] = v_rest
group.v['i%2 == 0'] = 'rand() * v_rest'
group.v[0:5] = 'v_rest + 10 * mV'
condition = 'abs(i-j)<=5'
syn.connect(condition=condition, p=0.999, n=2)
syn.w = '1 * mV'
net = Network(group, spikegen, po_grp, syn)
mon = StateMonitor(syn, 'w', record=True)
mon2 = SpikeMonitor(po_grp)
mon3 = EventMonitor(group, 'custom')
net.add(mon, mon2, mon3)
net.run(0.01 * ms)
md_str = device.md_text
assert _markdown_lint(md_str)
check = 'randn({sin({$w$}|$v_rest$ - $v$|/{\tau}})})'
assert _markdown_lint(check)
# check invalid strings
with pytest.raises(SyntaxError):
check = '**Initializing values at starting:*'
assert _markdown_lint(check)
check = '- Variable v$ of with $-79. mV$ to all members'
assert _markdown_lint(check)
check = 'randn({sin(})})'
assert _markdown_lint(check)
check = 'randn({sin({$w$}|$v_rest$ - $v$|/{\tau})})'
assert _markdown_lint(check)
device.reinit()
def before_run(self):
# set brian preferences
for key, value in self.extra_prefs.iteritems():
brian2.prefs[key] = value
if self.name is None:
raise NotImplementedError("You need to set the name attribute.")
brian2.set_device('cuda_standalone',
build_on_run=False,
**self.device_kwargs)
hostname = socket.gethostname()
dev_no_to_cc = None
if hostname == 'merope':
dev_no_to_cc = {0: '35'}
if hostname in ['elnath', 'adhara']:
dev_no_to_cc = {0: '20'}
elif hostname == 'sabik':
dev_no_to_cc = {0: '61', 1: '52'}
elif hostname == 'eltanin':
dev_no_to_cc = {0: '52', 1: '61', 2: '61', 3: '61'}
elif hostname == 'risha':
dev_no_to_cc = {0: '70'}
else:
logger.warn(
"Unknown hostname. Compiling with default args: {}"
"".format(
brian2.prefs['codegen.cuda.extra_compile_args_nvcc']))
if dev_no_to_cc is not None:
try:
gpu_device = int(os.environ['CUDA_VISIBLE_DEVICES'])
except KeyError:
# default
logger.info(
"Using GPU 0 (default). To run on another GPU, "
"set `CUDA_VISIBLE_DEVICES` environmental variable. "
"To run e.g. on GPU 1, prepend you python call with "
"`CUDA_VISIBLE_DEVICES=1 python <yourscript>.py` ")
gpu_device = 0
try:
cc = dev_no_to_cc[gpu_device]
except KeyError as err:
raise AttributeError("Unknown device number: {}".format(err))
print "Compiling device code for compute capability "\
"{}.{}".format(cc[0], cc[1])
logger.info("Compiling device code for compute capability {}.{}"
"".format(cc[0], cc[1]))
arch_arg = '-arch=sm_{}'.format(cc)
brian2.prefs['codegen.cuda.extra_compile_args_nvcc'].remove(
'-arch=sm_35')
brian2.prefs['codegen.cuda.extra_compile_args_nvcc'].extend(
[arch_arg])
def test_plot_synapses():
set_device('runtime')
group = NeuronGroup(10, 'dv/dt = -v/(10*ms) : volt', threshold='False')
group.v = np.linspace(0, 1, 10)*mV
synapses = Synapses(group, group, 'w : volt', on_pre='v += w')
synapses.connect('i != j')
synapses.w = 'i*0.1*mV'
# Just checking whether the plotting does not fail with an error and that
# it retuns an Axis object as promised
ax = brian_plot(synapses)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = brian_plot(synapses.w)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = brian_plot(synapses.delay)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j, plot_type='scatter')
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j, plot_type='image')
add_background_pattern(ax)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j, plot_type='hexbin')
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j, synapses.w)
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j, synapses.w, plot_type='scatter')
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j, synapses.w, plot_type='image')
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
ax = plot_synapses(synapses.i, synapses.j, synapses.w, plot_type='hexbin')
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
synapses.connect('i > 5') # More than one synapse per connection
brian_plot(synapses)
plt.close()
# It should be possible to plot synaptic variables for multiple connections
# with hexbin
ax = plot_synapses(synapses.i, synapses.j, synapses.w, plot_type='hexbin')
assert isinstance(ax, matplotlib.axes.Axes)
plt.close()
def test_synapse_connect_generator():
# connector test 3
start_scope()
set_device('exporter', build_on_run=False)
tau = 1 * ms
eqn = 'dv/dt = (1 - v)/tau :1'
Source = NeuronGroup(10, eqn, method='exact', threshold='v>0.9')
S1 = Synapses(Source, Source)
nett2 = Network(Source, S1)
S1.connect(j='k for k in range(0, i+1)')
nett2.run(1 * ms)
connect3 = device.runs[0]['initializers_connectors'][0]
assert connect3['j'] == 'k for k in range(0, i+1)'
device.reinit()
def test_ExportDevice_unsupported():
"""
Test whether unsupported objects for standard format export
are raising Error
"""
start_scope()
set_device('exporter')
eqn = '''
v = 1 :1
g :1
'''
G = NeuronGroup(1, eqn)
_ = PoissonInput(G, 'g', 1, 1 * Hz, 1)
# with pytest.raises(NotImplementedError):
run(10 * ms)
def before_run(self):
brian2.prefs.reset_to_defaults()
if self.single_precision:
brian2.prefs['core.default_float_dtype'] = brian2.float32
brian2.set_device('cpp_standalone',
build_on_run=False,
profile=self.profile)
brian2.prefs[
'devices.cpp_standalone.openmp_threads'] = self.openmp_threads
brian2.prefs._backup()
if self.known:
logger.info("Running CPPStandaloneConfigurationOpenMP with {} "
"threads".format(self.openmp_threads))
else:
logger.warn("Unknown hostname. Using number of logical cores ({}) "
"as threads for CPPStandaloneConfigurationOpenMP"
"".format(self.openmp_threads))
def before_run(self):
# set brian preferences
for key, value in self.extra_prefs.iteritems():
prefs[key] = value
if self.name is None:
raise NotImplementedError("You need to set the name attribute.")
brian2.set_device('cuda_standalone',
build_on_run=False,
**self.device_kwargs)
if socket.gethostname() == 'elnath':
if prefs['devices.cpp_standalone.extra_make_args_unix'] == [
'-j12'
]:
prefs['devices.cpp_standalone.extra_make_args_unix'] = ['-j24']
prefs['codegen.cuda.extra_compile_args_nvcc'].remove('-arch=sm_35')
prefs['codegen.cuda.extra_compile_args_nvcc'].extend(
['-arch=sm_20'])
def evaluate_with_dicts(self, param_dict):
b2.set_device('cpp_standalone')
# Simulate with parameter set
param_dict_units = glif_model.add_parameter_units(param_dict)
t, V, Th_s, Th_v, I_0, I_1, = glif_model.run_brian_sim(
self.input_current * b2.amp,
self.dt * b2.second,
self.init_values,
param_dict_units)
#Evaluate fitness
fitness = {x: self.fitness[x](t, self.target_voltage, V) for x in self.fitness.keys()}
b2.device.delete(force = True)
b2.device.reinit()
return fitness
def setup_standalone(request):
# Workaround to avoid issues with Network instances still around
Network.__instances__().clear()
set_device('cpp_standalone', directory=None)
dt = 0.01 * ms
tf = TraceFitter(dt=dt,
model=model,
input_var='v',
output_var='I',
input=input_traces,
output=output_traces,
n_samples=2)
def fin():
reinit_devices()
set_device('runtime')
request.addfinalizer(fin)
return dt, tf
def test_synapse_connect_ij():
# connector test 2
start_scope()
set_device('exporter', build_on_run=False)
tau = 10 * ms
eqn = 'dv/dt = (1 - v)/tau :1'
my_prob = -1
Source = NeuronGroup(10, eqn, method='exact', threshold='v>0.9')
S1 = Synapses(Source, Source)
nett = Network(Source, S1)
S1.connect(i=[0, 1], j=[1, 2], p='my_prob')
nett.run(1 * ms)
connect2 = device.runs[0]['initializers_connectors'][0]
assert connect2['i'] == [0, 1]
assert connect2['j'] == [1, 2]
assert connect2['identifiers']['my_prob'] == -1
with pytest.raises(KeyError):
connect2['condition']
device.reinit()
def test_simulation1(plot=False):
"""
Test example 1: simulation1_lif.py
"""
current_path = os.getcwd()
tempdir = tempfile.mkdtemp()
outbrian = simulation1(False, path=tempdir)
outnml = simulation1(True, path=tempdir)
set_device('runtime')
os.chdir(JNML_PATH)
outcommand = call("jnml {path} -nogui".format(
path=os.path.join(current_path, xml_filename)),
shell=True)
timevec = []
valuesvec = []
with open(output_jnml_file + '.dat', 'r') as f:
for line in f:
timevec.append(float(line.split("\t")[0]))
valuesvec.append([float(x) for x in line.split("\t")[1:-1]])
timevec = np.asarray(timevec)
valuesvec = np.asarray(valuesvec).T
for i in range(len(idx_to_record)):
assert_allclose(outbrian[i, :], valuesvec[i, 1:], atol=1e-02)
if plot:
plt.subplot(3, 2, 1)
plt.plot(outbrian[0, :])
plt.subplot(3, 2, 2)
plt.plot(valuesvec[0, :])
plt.subplot(3, 2, 3)
plt.plot(outbrian[1, :])
plt.subplot(3, 2, 4)
plt.plot(valuesvec[1, :])
plt.subplot(3, 2, 5)
plt.plot(outbrian[2, :])
plt.subplot(3, 2, 6)
plt.plot(valuesvec[2, :])
plt.show()
os.chdir(current_path)
def test_user_options():
"""
Test user options and error raising
"""
link = '<img src="https://render.githubusercontent.com/render/math?math='
my_expander = MdExpander(github_md=True, author='Brian', add_meta=True)
set_device('markdown', expander=my_expander)
grp = NeuronGroup(1, 'w :1')
run(0*ms)
string = device.md_text
regex = '_Filename: .*\
\nAuthor: .*\
\nDate and localtime: .*\
\nBrian version: .*'
assert re.match(regex, string)
assert _markdown_lint(string)
assert '$' not in string
assert link in string
device.reinit()
set_device('markdown', filename=10)
with pytest.raises(Exception):
run(0*ms)
device.reinit()
set_device('markdown', expander=NeuronGroup)
with pytest.raises(NotImplementedError):
run(0*ms)
device.reinit()
def before_run(self):
# set brian preferences
for key, value in self.extra_prefs.iteritems():
prefs[key] = value
if self.name is None:
raise NotImplementedError("You need to set the name attribute.")
brian2.set_device('cuda_standalone',
build_on_run=False,
**self.device_kwargs)
if socket.gethostname() == 'elnath':
prefs['codegen.cuda.extra_compile_args_nvcc'].remove('-arch=sm_35')
prefs['codegen.cuda.extra_compile_args_nvcc'].extend(
['-arch=sm_20'])
elif socket.gethostname() == 'sabik':
try:
dev_no = int(os.environ['CUDA_VISIBLE_DEVICES'])
except KeyError:
# uses first GPU by default
dev_no = 0
dev_no_to_cc = {0: '61', 1: '52'}
cc = dev_no_to_cc[dev_no]
prefs['codegen.cuda.extra_compile_args_nvcc'].remove('-arch=sm_35')
prefs['codegen.cuda.extra_compile_args_nvcc'].extend(
['-arch=sm_{}'.format(cc)])
def test_custom_expander():
"""
Test custom expander class
"""
class Custom(MdExpander):
def expand_NeuronGroup(self, grp_dict):
idt = self.expand_identifiers(grp_dict['identifiers'])
return "This is my custom neurongroup: " + grp_dict['name'] + idt
def expand_StateMonitor(self, mon_dict):
return "I monitor " + mon_dict['source']
def expand_identifiers(self, identifiers):
return 'Identifiers are not shown'
custom_expander = Custom(brian_verbose=True)
set_device('markdown', expander=custom_expander)
# check custom expander
v_rest = -79 * mV
rate = 10 * Hz
grp = NeuronGroup(10, 'v = v_rest:volt')
mon = StateMonitor(grp, 'v', record=True)
pog = PoissonGroup(10, rates=rate)
run(0.1*ms)
text = device.md_text
assert _markdown_lint(text)
# brian_verbose check
assert 'NeuronGroup' in text
assert 'StateMonitor' in text
assert 'Activity recorder' not in text
assert 'Initializing' in text
assert 'Identifiers are not shown' in text
assert 'I monitor ' in text
assert 'This is my custom neurongroup: neurongroup' in text
device.reinit()
def test_synapse_connect_cond():
# check connectors
start_scope()
set_device('exporter')
eqn = 'dv/dt = (1 - v)/tau :1'
tau = 1 * ms
P = NeuronGroup(5, eqn, method='euler', threshold='v>0.8')
Q = NeuronGroup(10, eqn, method='euler', threshold='v>0.9')
w = 1
tata = 2
bye = 2
my_prob = -1
S = Synapses(P, Q, on_pre='v += w')
S.connect('tata > bye', p='my_prob', n=5)
run(1 * ms)
connect = device.runs[0]['initializers_connectors'][0]
assert connect['probability'] == 'my_prob'
assert connect['n_connections'] == 5
assert connect['type'] == 'connect'
assert connect['identifiers']['tata'] == bye
with pytest.raises(KeyError):
connect['i']
connect['j']
device.reinit()
def run_network(duration,
beta=0.0,
w_ee_init=0.1,
rate_ext=5,
N=5000,
save_spikes=True,
pre_sim=1,
monitor_weights=True,
eta=2.,
plastic=False,
tau_p=0.3,
kappa=5,
tau_c=1,
c=0.1,
gamma=5.5,
spike_rec_ival=20 * 60,
output_dir=None,
w_ei=1,
dt_wmon=10):
"""
:param duration: length of simulation (in seconds)
:param beta: strength of presynaptic inhibition
:param w_ee_init: initial weights for E-E connections
:param rate_ext: population rate of external Poisson input
:param N: total number of neurons
:param save_spikes: whether to save spike times (takes memory!)
:param pre_sim: simulation length before starting plasticity (in seconds)
:param monitor_weights: whether to track E-E weights
:param eta: learning rate (scales plasticity time constant)
:param plastic: whether E-E weights are plastic
:param tau_p: timescale of presynaptic inhibition
:param kappa: target rate
:param tau_c: timescale of homeostatic control
:param c: connection probability
:param gamma: E/I balance factor for weights
:param spike_rec_ival: interval between recording spikes
:param output_dir: directory where to compile the code
:param w_ei: scales strength of I->E connection
:param dt_wmon: timestep of recording weights (in seconds)
Returns spike monitor (Brian object), rate monitor (as numpy array) and weight monitor (as Brian object)
"""
# ----------------------------- #
# Set up brian environment #
# ----------------------------- #
b2.start_scope()
b2.set_device(
'cpp_standalone',
build_on_run=False) # ensures code is run in c++ only (speed!)
b2.prefs.codegen.cpp.headers += ['"run.h"'
] # This is necessary to use brian_end()
b2.prefs.core.default_float_dtype = np.float32 # only used 32 bit floats (memory & speed)
# ------------------------------- #
# Default network parameters #
# ------------------------------- #
# paremeters for monitoring the rate
dt_rate = 10 * ms # monitor rate every 100 ms
tau_rate = 20 * ms
# network size dependent parameters
N_e = int(N * (4 / 5))
N_i = int(N * (1 / 5))
N_ext = 2 * int(N / 5)
# neuron parameters
taue = 10 * ms
taui = 10 * ms
taup = tau_p * 1000 * ms
Vt = -50 * mV
Vr = -70 * mV
taum_e = 20
taum_i = 20
# synaptic weight parameters
J = 0.5
# w_ie = we/np.sqrt(c*N_e)*J
# w_ei = gamma*we/np.sqrt(c*N_i)*J
# w_ii = gamma*we/np.sqrt(c*N_i)*J
w_ie = J * mV
w_ei = -w_ei * J * gamma * mV
w_ii = -J * gamma * mV
w_ext = 2 * mV
w0 = w_ee_init * mV # initial weight for EE connections
w_max = 5 * w0 # maximum weight
# GABA spillover and presynaptic inhibition
IE_ratefrac = taum_i / taum_e
A_GABA = IE_ratefrac / (
c * N_i
) / taui * second # amount of GABA released for every inhibitory spike (indep. of timescale)
p_init = np.clip(1 - beta * kappa, 0, 1)
if plastic:
w0 /= p_init
etap = 1
if beta == 0: # disable changes in p if presynaptic inhibition inactive, beta = 0 means psi off
etap = 0
# plasticity parameters
tauplus = 16.8 * ms
tauminus = 33.7 * ms
tauslow = 114 * ms
Aplus = 6.5 * 10**(-3) # amplitude of potentiation events
eta_w = 0 * mV # plasticity is off initially
w_min = 0
tau_c = tau_c * 1000 * ms
kappa = kappa * Hz
pref = Aplus * tauplus * tauslow / (
tauminus * kappa) # prefactor of adaptive depression amplitude term
# ------------------------------- #
# Model equations in Brian2 #
# ------------------------------- #
# dynamics for excitatory and inhibitory neurons
eqs = '''
dv/dt = ((Vr-v) + g_e + g_i) /taum : volt (unless refractory)
dg_e/dt = -g_e/taue : volt
dg_i/dt = -g_i/taui : volt
dGABA/dt = -GABA/taui: 1
dp/dt = (-p + clip(1-beta*GABA,0,1))*etap/taup : 1
taum : second
dzplus/dt = -zplus /tauplus : 1
dzminus/dt = -zminus /tauminus : 1
dnu/dt = -nu/tau_c : Hz
'''
neurons = b2.NeuronGroup(N,
eqs,
threshold='v>Vt',
refractory=5 * ms,
method='rk4',
reset='''v=Vr
zplus+=1
zminus+=1
nu+=1/tau_c''')
exc_neurons = neurons[:N_e]
inh_neurons = neurons[N_e:]
# set initial value for single neurons
neurons.v = 'Vr + rand() * (Vt - Vr)'
neurons.g_e = 'rand()*w_ie'
neurons.g_i = 'rand()*w_ii'
exc_neurons.taum = taum_e * ms
inh_neurons.taum = taum_i * ms
neurons.p = p_init
neurons.nu = kappa # set target rate
# synapse models
syn_ee = b2.Synapses(
exc_neurons,
exc_neurons, # E-E connections are plastic and subject to presynaptic inhibition
'''w_ee : volt
dzslow/dt = -zslow/tauslow : 1 (event-driven)''',
on_pre='''g_e += p*w_ee
w_ee -= eta_w*pref*(nu_post**2)*zminus_post
w_ee = clip(w_ee,w_min,w_max)''', # depression
on_post='''w_ee += eta_w*Aplus*zplus_pre*zslow
w_ee = clip(w_ee,w_min,w_max)
zslow += 1''',
method='euler') # potentiation
syn_ie = b2.Synapses(exc_neurons, inh_neurons, on_pre='g_e += w_ie')
syn_ei = b2.Synapses(inh_neurons,
exc_neurons,
on_pre='''g_i += w_ei
GABA += A_GABA'''
) # GABA spillover
syn_ii = b2.Synapses(inh_neurons, inh_neurons, on_pre='g_i += w_ii')
# connection lists for EE, EI, IE and II
connections = {}
pre_idx, post_idx = create_synapses(N_e, N_e, c, autapse=False)
connections['ee'] = np.array([pre_idx, post_idx])
pre_idx, post_idx = create_synapses(N_e, N_i, c)
connections['ie'] = np.array([pre_idx, post_idx])
pre_idx, post_idx = create_synapses(N_i, N_e, c)
connections['ei'] = np.array([pre_idx, post_idx])
pre_idx, post_idx = create_synapses(N_i, N_i, c, autapse=False)
connections['ii'] = np.array([pre_idx, post_idx])
# connect populations using the connection lists
syn_ee.connect(i=connections['ee'][0], j=connections['ee'][1])
syn_ee.w_ee = w0
syn_ie.connect(i=connections['ie'][0], j=connections['ie'][1])
syn_ei.connect(i=connections['ei'][0], j=connections['ei'][1])
syn_ii.connect(i=connections['ii'][0], j=connections['ii'][1])
# external input
neurons_ext = b2.PoissonGroup(N_ext, rate_ext * Hz)
syn_ext = b2.Synapses(neurons_ext, neurons, on_pre='g_e += w_ext')
pre_idx, post_idx = create_synapses(N_ext, N, c)
syn_ext.connect(i=pre_idx, j=post_idx)
# ---------------------------------------------- #
# Code to allows interruptions of simulation #
# ---------------------------------------------- #
# - stops run if network activity is pathologically high
# - implementation of stopping function needs to be in C++
@implementation(CPPStandaloneCodeObject, '''
double stop_if_too_high(double rate, double t, double add) {
if ((rate > 190) && (t>add+0.5)) {
brian_end(); // save all data to disk
std::exit(0);
}
return 0.0;
}
''')
@implementation('numpy', discard_units=True)
@check_units(rate=Hz, t=second, add=1, result=1)
def stop_if_too_high(rate, t, add):
if rate > 190 * Hz and t > (add + 0.5) * second:
b2.stop()
# Instantaneous rate is tracked by external population connected to first 1000 neurons
instant_rate = b2.NeuronGroup(1,
'''rate : Hz
drate_mon/dt = -rate_mon/tau_rate : Hz''',
threshold='True',
reset='rate=0*Hz',
method='exact')
con = b2.Synapses(exc_neurons[:1000],
instant_rate,
on_pre='''rate += 1.0/N_incoming/dt
rate_mon += 1.0/N_incoming/tau_rate'''
)
con.connect()
instant_rate.run_regularly('dummy = stop_if_too_high(rate, t, pre_sim)',
when='after_synapses')
# ------------------- #
# Set up monitors #
# ------------------- #
rate_mon = b2.StateMonitor(instant_rate,
'rate_mon',
dt=dt_rate,
record=True)
spike_mon = 0 # in case simulation is interrupted, spike_mon needs to exist
if monitor_weights:
wmon = b2.StateMonitor(syn_ee,
'w_ee',
record=np.arange(500),
dt=dt_wmon * 1000 *
ms) # (monitor first 500 weights)
else:
wmon = 0
# ------------------- #
# Start simulation #
# ------------------- #
# run for some time before plasticity is turned on
b2.run(pre_sim * second)
# switch plasticity on
if plastic:
eta_w = eta * mV
# if spikes should be monitored - do that in the beginning and end of the simulation only (memory!)
if save_spikes:
spike_record_interval = np.minimum(spike_rec_ival, duration)
b2.run((duration - spike_rec_ival) * second)
spike_mon = b2.SpikeMonitor(exc_neurons[:1000])
b2.run(5 * second)
spike_mon.active = False
b2.run(spike_rec_ival * second)
spike_mon.active = True
b2.run(5 * second)
else:
spike_mon = 0
b2.run(duration * second)
# this compiles the code and runs it
b2.device.build(directory=output_dir,
compile=True,
run=True,
debug=False,
clean=True)
# postprocessing of raw rate data to numpy array
rate_e = np.vstack((np.array(rate_mon.t), np.array(rate_mon.rate_mon))).T
rate_i = None # inh rate not monitored
return spike_mon, rate_e, wmon
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.set_device('runtime')
brian2.prefs.codegen.target = 'weave'
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.set_device('runtime')
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.set_device('cpp_standalone')
brian2.prefs.devices.cpp_standalone.openmp_threads = 4
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.set_device('cpp_standalone')
def before_run(self):
brian2.set_device('cuda_standalone')
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.set_device('cpp_standalone', build_on_run=False)
def main_simulation(params):
"""
Initialise simulation objects and run the simulation.
"""
(neuron_params, connection_params, monitor_params, run_params,
analysis_params) = params
spike_filename = os.path.basename(run_params['input_spikes_filename'])
run_id = spike_filename.replace('.pickle', '')
if not run_params['from_paramfile']:
param_mod.record_params(params, run_id)
input_spikes = load_input(run_params)
input_end_time = np.ceil(np.amax(input_spikes['times']))
if 'run_time' not in run_params:
run_params['run_time'] = input_end_time
if not run_params['no_standalone']:
if os.name == 'nt':
build_dir = 'C:\\temp\\'
else:
build_dir = '/tmp/'
build_dir += run_id
b2.set_device('cpp_standalone', directory=build_dir)
print("Initialising neurons...")
neurons = init_neurons(
input_spikes, run_params['layer_n_neurons'],
neuron_params
)
print("done!")
print("Initialising connections...")
connections = init_connections(
neurons,
connection_params
)
print("done!")
print("Initialising monitors...")
monitors = init_monitors(neurons, connections, monitor_params)
print("done!")
print("Running simulation...")
net = run_simulation(run_params, neurons, connections, monitors, run_id)
print("done!")
analyse_results(
monitors,
connections,
analysis_params
)
if analysis_params['save_figs']:
utils_mod.save_figures(run_id)
if run_params['save_results']:
print("Saving results...")
pickle_results(monitors, run_id)
print("done!")
if 'layer1vis' in monitors['neurons']:
print("Saving visualisation variables...")
pickle_visualisation(monitors, connections, run_id)
print("done!")
return (neurons, connections, monitors, net)
def run_net(tr):
# prefs.codegen.target = 'numpy'
# prefs.codegen.target = 'cython'
set_device('cpp_standalone',
directory='./builds/%.4d' % (tr.v_idx),
build_on_run=False)
print("Started process with id ", str(tr.v_idx))
T = tr.T1 + tr.T2 + tr.T3
namespace = tr.netw.f_to_dict(short_names=True, fast_access=True)
namespace['idx'] = tr.v_idx
defaultclock.dt = tr.netw.sim.dt
GExc = NeuronGroup(
N=tr.N_e,
model=tr.condlif_sig,
threshold=tr.nrnEE_thrshld,
reset=tr.nrnEE_reset, #method=tr.neuron_method,
namespace=namespace)
GInh = NeuronGroup(
N=tr.N_i,
model=tr.condlif_sig,
threshold='V > Vt',
reset='V=Vr_i', #method=tr.neuron_method,
namespace=namespace)
# set initial thresholds fixed, init. potentials uniformly distrib.
GExc.sigma, GInh.sigma = tr.sigma_e, tr.sigma_i
GExc.Vt, GInh.Vt = tr.Vt_e, tr.Vt_i
GExc.V , GInh.V = np.random.uniform(tr.Vr_e/mV, tr.Vt_e/mV,
size=tr.N_e)*mV, \
np.random.uniform(tr.Vr_i/mV, tr.Vt_i/mV,
size=tr.N_i)*mV
print("need to fix?")
synEE_pre_mod = mod.synEE_pre
synEE_post_mod = mod.synEE_post
if tr.PInp_mode == 'pool':
PInp = PoissonGroup(tr.NPInp, rates=tr.PInp_rate, namespace=namespace)
sPN = Synapses(target=GExc,
source=PInp,
model=tr.poisson_mod,
on_pre='ge_post += a_EPoi',
namespace=namespace)
sPN_src, sPN_tar = generate_connections(N_tar=tr.N_e,
N_src=tr.NPInp,
p=tr.p_EPoi)
elif tr.PInp_mode == 'indep':
PInp = PoissonGroup(tr.N_e, rates=tr.PInp_rate, namespace=namespace)
sPN = Synapses(target=GExc,
source=PInp,
model=tr.poisson_mod,
on_pre='ge_post += a_EPoi',
namespace=namespace)
sPN_src, sPN_tar = range(tr.N_e), range(tr.N_e)
sPN.connect(i=sPN_src, j=sPN_tar)
if tr.PInp_mode == 'pool':
sPNInh = Synapses(target=GInh,
source=PInp,
model=tr.poisson_mod,
on_pre='ge_post += a_EPoi',
namespace=namespace)
sPNInh_src, sPNInh_tar = generate_connections(N_tar=tr.N_i,
N_src=tr.NPInp,
p=tr.p_EPoi)
elif tr.PInp_mode == 'indep':
PInp_inh = PoissonGroup(tr.N_i,
rates=tr.PInp_rate,
namespace=namespace)
sPNInh = Synapses(target=GInh,
source=PInp_inh,
model=tr.poisson_mod,
on_pre='ge_post += a_EPoi',
namespace=namespace)
sPNInh_src, sPNInh_tar = range(tr.N_i), range(tr.N_i)
sPNInh.connect(i=sPNInh_src, j=sPNInh_tar)
if tr.stdp_active:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.synEE_pre_STDP)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.synEE_post_STDP)
if tr.synEE_rec:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.synEE_pre_rec)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.synEE_post_rec)
# E<-E advanced synapse model, rest simple
SynEE = Synapses(
target=GExc,
source=GExc,
model=tr.synEE_mod,
on_pre=synEE_pre_mod,
on_post=synEE_post_mod,
#method=tr.synEE_method,
namespace=namespace)
SynIE = Synapses(target=GInh,
source=GExc,
on_pre='ge_post += a_ie',
namespace=namespace)
SynEI = Synapses(target=GExc,
source=GInh,
on_pre='gi_post += a_ei',
namespace=namespace)
SynII = Synapses(target=GInh,
source=GInh,
on_pre='gi_post += a_ii',
namespace=namespace)
if tr.strct_active:
sEE_src, sEE_tar = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=sEE_src, j=sEE_tar)
SynEE.syn_active = 0
else:
srcs_full, tars_full = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=srcs_full, j=tars_full)
SynEE.syn_active = 0
sIE_src, sIE_tar = generate_connections(tr.N_i, tr.N_e, tr.p_ie)
sEI_src, sEI_tar = generate_connections(tr.N_e, tr.N_i, tr.p_ei)
sII_src, sII_tar = generate_connections(tr.N_i, tr.N_i, tr.p_ii, same=True)
SynIE.connect(i=sIE_src, j=sIE_tar)
SynEI.connect(i=sEI_src, j=sEI_tar)
SynII.connect(i=sII_src, j=sII_tar)
tr.f_add_result('sIE_src', sIE_src)
tr.f_add_result('sIE_tar', sIE_tar)
tr.f_add_result('sEI_src', sEI_src)
tr.f_add_result('sEI_tar', sEI_tar)
tr.f_add_result('sII_src', sII_src)
tr.f_add_result('sII_tar', sII_tar)
SynEE.a = tr.a_ee
SynEE.insert_P = tr.insert_P
SynEE.p_inactivate = tr.p_inactivate
# make synapse active at beginning
SynEE.run_regularly(tr.synEE_p_activate, dt=T, when='start', order=-100)
# synaptic scaling
if tr.netw.config.scl_active:
SynEE.summed_updaters['Asum_post']._clock = Clock(
dt=tr.dt_synEE_scaling)
SynEE.run_regularly(tr.synEE_scaling,
dt=tr.dt_synEE_scaling,
when='end')
# intrinsic plasticity
if tr.netw.config.it_active:
GExc.h_ip = tr.h_ip
GExc.run_regularly(tr.intrinsic_mod, dt=tr.it_dt, when='end')
# structural plasticity
if tr.netw.config.strct_active:
if tr.strct_mode == 'zero':
if tr.turnover_rec:
strct_mod = '''%s
%s''' % (tr.strct_mod, tr.turnover_rec_mod)
else:
strct_mod = tr.strct_mod
SynEE.run_regularly(strct_mod, dt=tr.strct_dt, when='end')
elif tr.strct_mode == 'thrs':
if tr.turnover_rec:
strct_mod_thrs = '''%s
%s''' % (tr.strct_mod_thrs,
tr.turnover_rec_mod)
else:
strct_mod_thrs = tr.strct_mod_thrs
SynEE.run_regularly(strct_mod_thrs, dt=tr.strct_dt, when='end')
# -------------- recording ------------------
#run(tr.sim.preT)
GExc_recvars = []
if tr.memtraces_rec:
GExc_recvars.append('V')
if tr.vttraces_rec:
GExc_recvars.append('Vt')
if tr.getraces_rec:
GExc_recvars.append('ge')
if tr.gitraces_rec:
GExc_recvars.append('gi')
GInh_recvars = GExc_recvars
GExc_stat = StateMonitor(GExc,
GExc_recvars,
record=[0, 1, 2],
dt=tr.GExc_stat_dt)
GInh_stat = StateMonitor(GInh,
GInh_recvars,
record=[0, 1, 2],
dt=tr.GInh_stat_dt)
SynEE_recvars = []
if tr.synee_atraces_rec:
SynEE_recvars.append('a')
if tr.synee_Apretraces_rec:
SynEE_recvars.append('Apre')
if tr.synee_Aposttraces_rec:
SynEE_recvars.append('Apost')
SynEE_stat = StateMonitor(SynEE,
SynEE_recvars,
record=range(tr.n_synee_traces_rec),
when='end',
dt=tr.synEE_stat_dt)
GExc_spks = SpikeMonitor(GExc)
GInh_spks = SpikeMonitor(GInh)
PInp_spks = SpikeMonitor(PInp)
GExc_rate = PopulationRateMonitor(GExc)
GInh_rate = PopulationRateMonitor(GInh)
PInp_rate = PopulationRateMonitor(PInp)
SynEE_a = StateMonitor(SynEE, ['a', 'syn_active'],
record=range(tr.N_e * (tr.N_e - 1)),
dt=T / tr.synee_a_nrecpoints,
when='end',
order=100)
if tr.PInp_mode == 'indep':
net = Network(GExc, GInh, PInp, sPN, sPNInh, SynEE, SynEI, SynIE,
SynII, GExc_stat, GInh_stat, SynEE_stat, SynEE_a,
GExc_spks, GInh_spks, PInp_spks, GExc_rate, GInh_rate,
PInp_rate, PInp_inh)
else:
net = Network(GExc, GInh, PInp, sPN, sPNInh, SynEE, SynEI, SynIE,
SynII, GExc_stat, GInh_stat, SynEE_stat, SynEE_a,
GExc_spks, GInh_spks, PInp_spks, GExc_rate, GInh_rate,
PInp_rate)
net.run(tr.sim.T1, report='text')
# SynEE_a.record_single_timestep()
recorders = [
GExc_spks, GInh_spks, PInp_spks, SynEE_stat, GExc_stat, GInh_stat
]
rate_recorders = [GExc_rate, GInh_rate, PInp_rate]
for rcc in recorders:
rcc.active = False
net.run(tr.sim.T2, report='text')
recorders = [
SynEE_stat, GExc_stat, GInh_stat, GExc_rate, GInh_rate, PInp_rate
]
for rcc in recorders:
rcc.active = True
if tr.spks_rec:
GExc_spks.active = True
GInh_spks.active = True
# PInp_spks.active=True
net.run(tr.sim.T3, report='text')
device.build(directory='../builds/%.4d' % (tr.v_idx), clean=True)
# save monitors as raws in build directory
raw_dir = '../builds/%.4d/raw/' % (tr.v_idx)
if not os.path.exists(raw_dir):
os.makedirs(raw_dir)
with open(raw_dir + 'namespace.p', 'wb') as pfile:
pickle.dump(namespace, pfile)
with open(raw_dir + 'gexc_stat.p', 'wb') as pfile:
pickle.dump(GExc_stat.get_states(), pfile)
with open(raw_dir + 'ginh_stat.p', 'wb') as pfile:
pickle.dump(GInh_stat.get_states(), pfile)
with open(raw_dir + 'synee_stat.p', 'wb') as pfile:
pickle.dump(SynEE_stat.get_states(), pfile)
with open(raw_dir + 'synee_a.p', 'wb') as pfile:
pickle.dump(SynEE_a.get_states(), pfile)
with open(raw_dir + 'gexc_spks.p', 'wb') as pfile:
pickle.dump(GExc_spks.get_states(), pfile)
with open(raw_dir + 'ginh_spks.p', 'wb') as pfile:
pickle.dump(GInh_spks.get_states(), pfile)
with open(raw_dir + 'pinp_spks.p', 'wb') as pfile:
pickle.dump(PInp_spks.get_states(), pfile)
with open(raw_dir + 'gexc_rate.p', 'wb') as pfile:
pickle.dump(GExc_rate.get_states(), pfile)
pickle.dump(GExc_rate.smooth_rate(width=25 * ms), pfile)
with open(raw_dir + 'ginh_rate.p', 'wb') as pfile:
pickle.dump(GInh_rate.get_states(), pfile)
pickle.dump(GInh_rate.smooth_rate(width=25 * ms), pfile)
with open(raw_dir + 'pinp_rate.p', 'wb') as pfile:
pickle.dump(PInp_rate.get_states(), pfile)
pickle.dump(PInp_rate.smooth_rate(width=25 * ms), pfile)
# ----------------- add raw data ------------------------
fpath = '../builds/%.4d/' % (tr.v_idx)
from pathlib import Path
Path(fpath + 'turnover').touch()
turnover_data = np.genfromtxt(fpath + 'turnover', delimiter=',')
os.remove(fpath + 'turnover')
with open(raw_dir + 'turnover.p', 'wb') as pfile:
pickle.dump(turnover_data, pfile)
Path(fpath + 'spk_register').touch()
spk_register_data = np.genfromtxt(fpath + 'spk_register', delimiter=',')
os.remove(fpath + 'spk_register')
with open(raw_dir + 'spk_register.p', 'wb') as pfile:
pickle.dump(spk_register_data, pfile)
def run_net(tr):
# prefs.codegen.target = 'numpy'
# prefs.codegen.target = 'cython'
set_device('cpp_standalone',
directory='./builds/%.4d' % (tr.v_idx),
build_on_run=False)
print("Started process with id ", str(tr.v_idx))
namespace = tr.netw.f_to_dict(short_names=True, fast_access=True)
namespace['idx'] = tr.v_idx
defaultclock.dt = tr.netw.sim.dt
GExc = NeuronGroup(
N=tr.N_e,
model=tr.condlif_sig,
threshold=tr.nrnEE_thrshld,
reset=tr.nrnEE_reset, #method=tr.neuron_method,
namespace=namespace)
GInh = NeuronGroup(
N=tr.N_i,
model=tr.condlif_sig,
threshold='V > Vt',
reset='V=Vr_i', #method=tr.neuron_method,
namespace=namespace)
# set initial thresholds fixed, init. potentials uniformly distrib.
GExc.sigma, GInh.sigma = tr.sigma_e, tr.sigma_i
GExc.Vt, GInh.Vt = tr.Vt_e, tr.Vt_i
GExc.V , GInh.V = np.random.uniform(tr.Vr_e/mV, tr.Vt_e/mV,
size=tr.N_e)*mV, \
np.random.uniform(tr.Vr_i/mV, tr.Vt_i/mV,
size=tr.N_i)*mV
synEE_pre_mod = mod.synEE_pre
synEE_post_mod = mod.synEE_post
if tr.stdp_active:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.synEE_pre_STDP)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.synEE_post_STDP)
if tr.synEE_rec:
synEE_pre_mod = '''%s
%s''' % (synEE_pre_mod, mod.synEE_pre_rec)
synEE_post_mod = '''%s
%s''' % (synEE_post_mod, mod.synEE_post_rec)
# E<-E advanced synapse model, rest simple
SynEE = Synapses(
target=GExc,
source=GExc,
model=tr.synEE_mod,
on_pre=synEE_pre_mod,
on_post=synEE_post_mod,
#method=tr.synEE_method,
namespace=namespace)
SynIE = Synapses(target=GInh,
source=GExc,
on_pre='ge_post += a_ie',
namespace=namespace)
SynEI = Synapses(target=GExc,
source=GInh,
on_pre='gi_post += a_ei',
namespace=namespace)
SynII = Synapses(target=GInh,
source=GInh,
on_pre='gi_post += a_ii',
namespace=namespace)
if tr.strct_active:
sEE_src, sEE_tar = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=sEE_src, j=sEE_tar)
SynEE.syn_active = 0
else:
srcs_full, tars_full = generate_full_connectivity(tr.N_e, same=True)
SynEE.connect(i=srcs_full, j=tars_full)
SynEE.syn_active = 0
sIE_src, sIE_tar = generate_connections(tr.N_i, tr.N_e, tr.p_ie)
sEI_src, sEI_tar = generate_connections(tr.N_e, tr.N_i, tr.p_ei)
sII_src, sII_tar = generate_connections(tr.N_i, tr.N_i, tr.p_ii, same=True)
SynIE.connect(i=sIE_src, j=sIE_tar)
SynEI.connect(i=sEI_src, j=sEI_tar)
SynII.connect(i=sII_src, j=sII_tar)
tr.f_add_result('sIE_src', sIE_src)
tr.f_add_result('sIE_tar', sIE_tar)
tr.f_add_result('sEI_src', sEI_src)
tr.f_add_result('sEI_tar', sEI_tar)
tr.f_add_result('sII_src', sII_src)
tr.f_add_result('sII_tar', sII_tar)
# if tr.strct_active:
# SynEE.a = 0
# else:
SynEE.a = tr.a_ee
SynEE.insert_P = tr.insert_P
# make synapse active at beginning
#if not tr.strct_active:
SynEE.run_regularly(tr.synEE_p_activate, dt=tr.T, when='start', order=-100)
# synaptic scaling
if tr.netw.config.scl_active:
SynEE.summed_updaters['Asum_post']._clock = Clock(
dt=tr.dt_synEE_scaling)
SynEE.run_regularly(tr.synEE_scaling,
dt=tr.dt_synEE_scaling,
when='end')
# intrinsic plasticity
if tr.netw.config.it_active:
GExc.h_ip = tr.h_ip
GExc.run_regularly(tr.intrinsic_mod, dt=tr.it_dt, when='end')
# structural plasticity
if tr.netw.config.strct_active:
SynEE.run_regularly(tr.strct_mod, dt=tr.strct_dt, when='end')
# -------------- recording ------------------
#run(tr.sim.preT)
GExc_recvars = []
if tr.memtraces_rec:
GExc_recvars.append('V')
if tr.vttraces_rec:
GExc_recvars.append('Vt')
if tr.getraces_rec:
GExc_recvars.append('ge')
if tr.gitraces_rec:
GExc_recvars.append('gi')
GInh_recvars = GExc_recvars
GExc_stat = StateMonitor(GExc,
GExc_recvars,
record=[0, 1, 2],
dt=tr.GExc_stat_dt)
GInh_stat = StateMonitor(GInh,
GInh_recvars,
record=[0, 1, 2],
dt=tr.GInh_stat_dt)
SynEE_recvars = []
if tr.synee_atraces_rec:
SynEE_recvars.append('a')
if tr.synee_Apretraces_rec:
SynEE_recvars.append('Apre')
if tr.synee_Aposttraces_rec:
SynEE_recvars.append('Apost')
SynEE_stat = StateMonitor(SynEE,
SynEE_recvars,
record=range(tr.n_synee_traces_rec),
when='end',
dt=tr.synEE_stat_dt)
GExc_spks = SpikeMonitor(GExc)
GInh_spks = SpikeMonitor(GInh)
SynEE_a = StateMonitor(SynEE, ['a', 'syn_active'],
record=range(tr.N_e * (tr.N_e - 1)),
dt=tr.sim.T / 10.,
when='end',
order=100)
run(tr.sim.T, report='text')
SynEE_a.record_single_timestep()
device.build(directory='../builds/%.4d' % (tr.v_idx))
tr.v_standard_result = Brian2MonitorResult
tr.f_add_result('GExc_stat', GExc_stat)
tr.f_add_result('SynEE_stat', SynEE_stat)
print("Saving exc spikes... ", GExc_spks.get_states()['N'])
tr.f_add_result('GExc_spks', GExc_spks)
tr.f_add_result('GInh_stat', GInh_stat)
print("Saving inh spikes... ", GInh_spks.get_states()['N'])
tr.f_add_result('GInh_spks', GInh_spks)
tr.f_add_result('SynEE_a', SynEE_a)
# ----------------- add raw data ------------------------
fpath = '../builds/%.4d/' % (tr.v_idx)
from pathlib import Path
Path(fpath + 'turnover').touch()
turnover_data = np.genfromtxt(fpath + 'turnover', delimiter=',')
tr.f_add_result('turnover', turnover_data)
os.remove(fpath + 'turnover')
Path(fpath + 'spk_register').touch()
spk_register_data = np.genfromtxt(fpath + 'spk_register', delimiter=',')
tr.f_add_result('spk_register', spk_register_data)
os.remove(fpath + 'spk_register')
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.prefs.codegen.loop_invariant_optimisations = False
brian2.prefs.devices.genn.unix_compiler_flags = ""
windows_compiler_flags = ""
brian2.set_device("genn")
def before_run(self):
brian2.prefs.reset_to_defaults()
brian2.prefs.codegen.loop_invariant_optimisations = False
brian2.set_device("genn")
