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")