def run_network(traj): """Runs brian network consisting of 200 inhibitory IF neurons""" eqs = ''' dv/dt=(v0-v)/(5*ms) : volt (unless refractory) v0 : volt ''' group = NeuronGroup(100, model=eqs, threshold='v>10 * mV', reset='v = 0*mV', refractory=5*ms) group.v0 = traj.par.v0 group.v = np.random.rand(100) * 10.0 * mV syn = Synapses(group, group, on_pre='v-=1*mV') syn.connect('i != j', p=0.2) spike_monitor = SpikeMonitor(group, variables=['v']) voltage_monitor = StateMonitor(group, 'v', record=True) pop_monitor = PopulationRateMonitor(group, name='pop' + str(traj.v_idx)) net = Network(group, syn, spike_monitor, voltage_monitor, pop_monitor) net.run(0.25*second, report='text') traj.f_add_result(Brian2MonitorResult, 'spikes', spike_monitor) traj.f_add_result(Brian2MonitorResult, 'v', voltage_monitor) traj.f_add_result(Brian2MonitorResult, 'pop', pop_monitor)
def test_incorrect_dt_custom_clock(): clock = Clock(dt=0.5*ms) G = NeuronGroup(1, 'dv/dt = -v / (10*ms) : 1', clock=clock) net = Network(G) net.run(0.5*ms) clock.dt = 1*ms assert_raises(ValueError, lambda: net.run(0*ms))
def test_network_operations(): # test NetworkOperation and network_operation seq = [] def f1(): seq.append('a') op1 = NetworkOperation(f1, when='start', order=1) @network_operation def f2(): seq.append('b') @network_operation(when='end', order=1) def f3(): seq.append('c') # In complex frameworks, network operations might be object methods that # access some common data class Container(object): def __init__(self): self.g1_data = 'B' self.g2_data = 'C' def g1(self): seq.append(self.g1_data) def g2(self): seq.append(self.g2_data) c = Container() c_op1 = NetworkOperation(c.g1) c_op2 = NetworkOperation(c.g2, when='end', order=1) net = Network(op1, f2, f3, c_op1, c_op2) net.run(1*ms) assert_equal(''.join(seq), 'bBacC'*10)
def run_old_algorithm(params, network_objs): monitors = network_objs["monitors"] network_objs.pop("monitors") network_objs.update(monitors) @network_operation(dt=params["rate_interval"], order=1) def local_update(t): if t/ms == 0: # if this is t = 0, skip the computation return firing_rates = network_objs["Pi"].A / (params["rate_interval"] / second) network_objs["Pi"].A = 0 # apply the rate sensor to the single firing rates firing_rates = rate_sensor(firing_rates, params["x_NI"], params["sigma_s"]) temp_w_holder = np.array(network_objs["con_ei"].w) for neuron_idx in np.arange(params["NI"]): delta_w = params["eta"] * (firing_rates[neuron_idx] - params["rho_0"]) idxes = params["ei_conn_mat"][:,0] == neuron_idx temp_w_holder[idxes] += delta_w # set below 0 weights to zero. temp_w_holder = clip(temp_w_holder, params["wmin"], params["wmax"]) network_objs["con_ei"].w = temp_w_holder network_objs["local_update"] = local_update net = Network(list(set(network_objs.values()))) net.run(params["simtime"], report="stdout", profile= params["do_profiling"], namespace = params)
def test_incorrect_dt_defaultclock(): defaultclock.dt = 0.5*ms G = NeuronGroup(1, 'dv/dt = -v / (10*ms) : 1') net = Network(G) net.run(0.5*ms) defaultclock.dt = 1*ms assert_raises(ValueError, lambda: net.run(0*ms))
def test_progress_report_incorrect(): ''' Test wrong use of the report option ''' G = NeuronGroup(1, '') net = Network(G) assert_raises(ValueError, lambda: net.run(1*ms, report='unknown')) assert_raises(TypeError, lambda: net.run(1*ms, report=object()))
def test_network_different_when(): # Check that a network with different when attributes functions correctly NameLister.updates[:] = [] x = NameLister(name='x', when='start') y = NameLister(name='y', when='end') net = Network(x, y) net.run(0.3*ms) assert_equal(''.join(NameLister.updates), 'xyxyxy')
def test_profile_ipython_html(): G = NeuronGroup(10, 'dv/dt = -v / (10*ms) : 1', threshold='v>1', reset='v=0', name='profile_test') G.v = 1.1 net = Network(G) net.run(1*ms, profile=True) summary = profiling_summary(net) assert len(summary._repr_html_())
def test_network_different_clocks(): NameLister.updates[:] = [] # Check that a network with two different clocks functions correctly x = NameLister(name='x', dt=1*ms, order=0) y = NameLister(name='y', dt=3*ms, order=1) net = Network(x, y) net.run(10*ms) assert_equal(''.join(NameLister.updates), 'xyxxxyxxxyxxxy')
def test_defaultclock_dt_changes(): BrianLogger.suppress_name('resolution_conflict') for dt in [0.1*ms, 0.01*ms, 0.5*ms, 1*ms, 3.3*ms]: defaultclock.dt = dt G = NeuronGroup(1, 'v:1') mon = StateMonitor(G, 'v', record=True) net = Network(G, mon) net.run(2*dt) assert_equal(mon.t[:], [0, dt/ms]*ms)
def test_network_different_clocks(): # Check that a network with two different clocks functions correctly clock1 = Clock(dt=1*ms) clock3 = Clock(dt=3*ms) x = Updater(name='x', when=(clock1, 0)) y = Updater(name='y', when=(clock3, 1)) net = Network(x, y) net.run(10*ms) assert_equal(''.join(updates), 'xyxxxyxxxyxxxy')
def test_network_different_clocks(): NameLister.updates[:] = [] # Check that a network with two different clocks functions correctly x = NameLister(name='x', dt=.1*ms, order=0) y = NameLister(name='y', dt=1*ms, order=1) net = Network(x, y) net.run(100*second+defaultclock.dt, report='text') updates = ''.join(NameLister.updates)[2:] # ignore the first time step assert updates == ('xxxxxxxxxxy'*100000)
def test_network_before_after_schedule(): # Test that before... and after... slot names can be used NameLister.updates[:] = [] x = NameLister(name='x', when='before_resets') y = NameLister(name='y', when='after_thresholds') net = Network(x, y) net.schedule = ['thresholds', 'resets'] net.run(0.3*ms) assert_equal(''.join(NameLister.updates), 'yxyxyx')
def test_schedule_warning(): previous_device = get_device() from uuid import uuid4 # TestDevice1 supports arbitrary schedules, TestDevice2 does not class TestDevice1(Device): # These functions are needed during the setup of the defaultclock def get_value(self, var): return np.array([0.0001]) def add_array(self, var): pass def init_with_zeros(self, var, dtype): pass def fill_with_array(self, var, arr): pass class TestDevice2(TestDevice1): def __init__(self): super(TestDevice2, self).__init__() self.network_schedule = ['start', 'groups', 'synapses', 'thresholds', 'resets', 'end'] # Unique names are important for getting the warnings again for multiple # runs of the test suite name1 = 'testdevice_' + str(uuid4()) name2 = 'testdevice_' + str(uuid4()) all_devices[name1] = TestDevice1() all_devices[name2] = TestDevice2() set_device(name1) assert schedule_propagation_offset() == 0*ms net = Network() assert schedule_propagation_offset(net) == 0*ms # Any schedule should work net.schedule = list(reversed(net.schedule)) with catch_logs() as l: net.run(0*ms) assert len(l) == 0, 'did not expect a warning' assert schedule_propagation_offset(net) == defaultclock.dt set_device(name2) assert schedule_propagation_offset() == defaultclock.dt # Using the correct schedule should work net.schedule = ['start', 'groups', 'synapses', 'thresholds', 'resets', 'end'] with catch_logs() as l: net.run(0*ms) assert len(l) == 0, 'did not expect a warning' assert schedule_propagation_offset(net) == defaultclock.dt # Using another (e.g. the default) schedule should raise a warning net.schedule = None with catch_logs() as l: net.run(0*ms) assert len(l) == 1 and l[0][1].endswith('schedule_conflict') reset_device(previous_device)
def test_multiple_runs_defaultclock_incorrect(): defaultclock.dt = 0.1*ms G = NeuronGroup(1, 'dv/dt = -v / (10*ms) : 1') net = Network(G) net.run(0.5*ms) # The new dt is not compatible with the previous time since we cannot # continue at 0.5ms with a dt of 1ms defaultclock.dt = 1*ms assert_raises(ValueError, lambda: net.run(1*ms))
def test_network_custom_slots(): # Check that custom slots can be inserted into the schedule NameLister.updates[:] = [] x = NameLister(name='x', when='thresholds') y = NameLister(name='y', when='in_between') z = NameLister(name='z', when='resets') net = Network(x, y, z) net.schedule = ['start', 'groups', 'thresholds', 'in_between', 'synapses', 'resets', 'end'] net.run(0.3*ms) assert_equal(''.join(NameLister.updates), 'xyzxyzxyz')
def test_network_from_dict(): # Check that a network from a dictionary works x = Counter() y = Counter() d = dict(a=x, b=y) net = Network() net.add(d) net.run(1*ms) assert_equal(len(net.objects), 2) assert_equal(x.count, 10) assert_equal(y.count, 10)
def test_network_reinit_prepare(): # Check that reinit and prepare work x = Preparer() net = Network(x) assert_equal(x.did_reinit, False) assert_equal(x.did_prepare, False) net.run(1*ms) assert_equal(x.did_reinit, False) assert_equal(x.did_prepare, True) net.reinit() assert_equal(x.did_reinit, True)
def test_network_two_objects(): # Check that a network with two objects and the same clock function correctly x = Counter(order=5) y = Counter(order=6) net = Network() net.add([x, [y]]) # check that a funky way of adding objects work correctly assert_equal(net.objects[0].order, 5) assert_equal(net.objects[1].order, 6) assert_equal(len(net.objects), 2) net.run(1*ms) assert_equal(x.count, 10) assert_equal(y.count, 10)
def test_network_reinit_pre_post_run(): # Check that reinit and before_run and after_run work x = Preparer() net = Network(x) assert_equal(x.did_reinit, False) assert_equal(x.did_pre_run, False) assert_equal(x.did_post_run, False) net.run(1*ms) assert_equal(x.did_reinit, False) assert_equal(x.did_pre_run, True) assert_equal(x.did_post_run, True) net.reinit() assert_equal(x.did_reinit, True)
def test_network_custom_slots(): # Check that custom slots can be inserted into the schedule NameLister.updates[:] = [] x = NameLister(name='x', when='thresholds') y = NameLister(name='y', when='in_between') z = NameLister(name='z', when='resets') net = Network(x, y, z) net.schedule = [ 'start', 'groups', 'thresholds', 'in_between', 'synapses', 'resets', 'end' ] net.run(0.3 * ms) assert_equal(''.join(NameLister.updates), 'xyzxyzxyz')
def create_cache(configuration): model_paths = load_model_paths() neuron_counts = _read_neuron_counts(configuration) hidden_layer = create_non_input_layer(model_paths, neuron_counts.hidden, 'hidden') hidden_layer.Itau = get_current(15.3e-3) * amp number_of_output_neurons = 1 layers_connected_to_output = _get_layers_connected_to_output_count( configuration) output_layer = create_non_input_layer( model_paths, number_of_output_neurons, 'output', num_inputs=layers_connected_to_output) hidden_to_output_synapses = create_hidden_to_output_synapses( 'main', hidden_layer, output_layer, model_paths, neuron_counts) input_layer = create_input_layer('main', neuron_counts.input) input_to_hidden_synapses = create_input_to_hidden_synapses( name='main', input_layer=input_layer, hidden_layer=hidden_layer, model_paths=model_paths, neuron_counts=neuron_counts) spike_monitors = SpikeMonitors(hidden=SpikeMonitor(hidden_layer), output=SpikeMonitor(output_layer)) network = Network(input_layer, input_to_hidden_synapses, hidden_layer, spike_monitors.hidden, spike_monitors.output, output_layer, hidden_to_output_synapses) if should_add_artifact_filter(configuration): add_artifact_filter_to_network(model_paths, input_layer, output_layer, network) advanced_artifact_filter_input_layer = add_advanced_artifact_filter_to_network( network, output_layer, model_paths, neuron_counts ) if should_add_advanced_artifact_filter(configuration) else None network.store() return Cache( model_paths=model_paths, neuron_counts=neuron_counts, spike_monitors=spike_monitors, network=network, input_layer=input_layer, advanced_artifact_filter_input_layer= advanced_artifact_filter_input_layer, )
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_network_stop(): # test that Network.stop and global stop() work correctly net = Network() x = Stopper(10, net.stop) net.add(x) net.run(10 * ms) assert_equal(defaultclock.t, 1 * ms) del net defaultclock.t = 0 * second x = Stopper(10, stop) net = Network(x) net.run(10 * ms) assert_equal(defaultclock.t, 1 * ms)
def test_get_set_states(): G = NeuronGroup(10, 'v:1', name='a_neurongroup') G.v = 'i' net = Network(G) states1 = net.get_states() states2 = magic_network.get_states() states3 = net.get_states(read_only_variables=False) assert set(states1.keys()) == set(states2.keys()) == set(states3.keys()) == {'a_neurongroup'} assert set(states1['a_neurongroup'].keys()) == set(states2['a_neurongroup'].keys()) == {'i', 'dt', 'N', 't', 'v'} assert set(states3['a_neurongroup']) == {'v'} # Try re-setting the state G.v = 0 net.set_states(states3) assert_equal(G.v, np.arange(10))
def test_multiple_networks_invalid(): x = Counter() net = Network(x) net.run(1*ms) try: run(1*ms) raise AssertionError('Expected a RuntimeError') except RuntimeError: pass # this is expected try: net2 = Network(x) raise AssertionError('Expected a RuntimeError') except RuntimeError: pass # this is expected
def create_net(): # Use a bit of a complicated spike and connection pattern with # heterogeneous delays # Note: it is important that all objects have the same name, this would # be the case if we were running this in a new process but to not rely # on garbage collection we will assign explicit names here source = SpikeGeneratorGroup( 5, np.arange(5).repeat(3), [3, 4, 1, 2, 3, 7, 5, 4, 1, 0, 5, 9, 7, 8, 9] * ms, name='source') target = NeuronGroup(10, 'v:1', name='target') synapses = Synapses(source, target, model='w:1', on_pre='v+=w', name='synapses') synapses.connect('j>=i') synapses.w = 'i*1.0 + j*2.0' synapses.delay = '(5-i)*ms' state_mon = StateMonitor(target, 'v', record=True, name='statemonitor') input_spikes = SpikeMonitor(source, name='input_spikes') net = Network(source, target, synapses, state_mon, input_spikes) return net
def test_dependency_check(): def create_net(): G = NeuronGroup(10, 'v: 1', threshold='False') dependent_objects = [ StateMonitor(G, 'v', record=True), SpikeMonitor(G), PopulationRateMonitor(G), Synapses(G, G, pre='v+=1', connect=True) ] return dependent_objects dependent_objects = create_net() # Trying to simulate the monitors/synapses without the group should fail for obj in dependent_objects: assert_raises(ValueError, lambda: Network(obj).run(0*ms)) # simulation with a magic network should work when we have an explicit # reference to one of the objects, but the object should be inactive and # we should get a warning assert all(obj.active for obj in dependent_objects) for obj in dependent_objects: # obj is our explicit reference with catch_logs() as l: run(0*ms) dependency_warnings = [msg[2] for msg in l if msg[1] == 'brian2.core.magic.dependency_warning'] assert len(dependency_warnings) == 1 assert not obj.active
def test_profile(): G = NeuronGroup(10, 'dv/dt = -v / (10*ms) : 1', threshold='v>1', reset='v=0', name='profile_test') G.v = 1.1 net = Network(G) net.run(1*ms, profile=True) # The should be four simulated CodeObjects, one for the group and one each # for state update, threshold and reset info = net.profiling_info info_dict = dict(info) assert len(info) == 4 assert 'profile_test' in info_dict assert 'profile_test_stateupdater' in info_dict assert 'profile_test_thresholder' in info_dict assert 'profile_test_resetter' in info_dict assert all([t>=0*second for _, t in info])
def __init__( self, model: str = "dv/dt = -v/(10*ms) : volt", threshold: str = "v > -50*mV", reset="v = -70*mV", refractory: str = "5*ms", ) -> None: self._fire_callbacks = [] self._time_step_size_ms = 0.12 self._group = NeuronGroup(1, model, threshold=threshold, reset=reset, refractory=refractory) self._monitor = StateMonitor(self._group, ("v", ), record=[0]) self._net = Network(self._group, self._monitor)
def test_network_contains(): ''' Test `Network.__contains__`. ''' G = NeuronGroup(1, 'v:1', name='mygroup') net = Network(G) assert 'mygroup' in net assert 'neurongroup' not in net
def test_network_copy(): x = Counter() net = Network(x) net2 = Network() for obj in net.objects: net2.add(obj) net2.run(1*ms) assert_equal(x.count, 10) net.run(1*ms) assert_equal(x.count, 20)
def test_network_remove(): x = Counter() y = Counter() net = Network(x, y) net.remove(y) net.run(1*ms) assert_equal(x.count, 10) assert_equal(y.count, 0) # the relevance of this test is when we use weakref.proxy objects in # Network.objects, we should be able to add and remove these from # the Network just as much as the original objects # TODO: Does this test make sense now that Network does not store weak # references by default? for obj in copy.copy(net.objects): net.remove(obj) net.run(1*ms) assert_equal(x.count, 10) assert_equal(y.count, 0)
def setup_standalone(request): # Workaround to avoid issues with Network instances still around Network.__instances__().clear() set_device('cpp_standalone', directory=None) dt = 0.1 * ms duration = 10 * ms neurons = NeuronGroup(1, model, name='neurons') monitor = StateMonitor(neurons, 'I', record=True, name='monitor') net = Network(neurons, monitor) def fin(): reinit_devices() set_device('runtime') request.addfinalizer(fin) return net, dt, duration
def brianNetwork(self): #/####################/# # init the Network # #maybe should import from brian2 import Network #set self.BrianedNetworkVariable=Network() #/####################/# # adapt dimension time # #Check if self.BrianingTimeDimensionVariable==None: from brian2 import ms self.BrianingTimeDimensionVariable=ms #/####################/# # init a simulation clock # #debug self.debug( [ 'We set a simulation clock at least' ] ) #Check if 'Clocks' not in self.TeamDict: ClocksDeriveManager=self.team('Clocks').TeamedValueVariable else: ClocksDeriveManager=self.TeamDict['Clocks'] #manage if 'Simulation' not in ClocksDeriveManager.ManagementDict: #debug self.debug( [ 'We init a simulation clock here' ] ) #manage SimulationDeriveBrianer=ClocksDeriveManager.manage( 'Simulation', { 'BrianingStepTimeFloat':self.BrianingStepTimeFloat } )
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_network_stop(): # test that Network.stop and global stop() work correctly net = Network() x = Stopper(10, net.stop) net.add(x) net.run(10*ms) assert_equal(defaultclock.t, 1*ms) x = Stopper(10, stop) net = Network(x) net.run(10*ms) assert_equal(defaultclock.t, 1*ms)
def test_network_access(): x = Counter(name='counter') net = Network(x) assert len(net) == 1 # accessing objects assert net['counter'] is x assert_raises(TypeError, lambda: net[123]) assert_raises(TypeError, lambda: net[1:3]) assert_raises(KeyError, lambda: net['non-existing']) objects = [obj for obj in net] assert set(objects) == set(net.objects) # deleting objects del net['counter'] assert_raises(TypeError, lambda: net.__delitem__(123)) assert_raises(TypeError, lambda: net.__delitem__(slice(1, 3))) assert_raises(KeyError, lambda: net.__delitem__('counter'))
def test_store_restore_to_file_differing_nets(): # Check that the store/restore mechanism is not used with differing # networks filename = tempfile.mktemp(suffix='state', prefix='brian_test') source = SpikeGeneratorGroup(5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4] * ms, name='source_1') mon = SpikeMonitor(source, name='monitor') net = Network(source, mon) net.store(filename=filename) source_2 = SpikeGeneratorGroup(5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4] * ms, name='source_2') mon = SpikeMonitor(source_2, name='monitor') net = Network(source_2, mon) assert_raises(KeyError, lambda: net.restore(filename=filename)) net = Network(source) # Without the monitor assert_raises(KeyError, lambda: net.restore(filename=filename))
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_multiple_runs_defaultclock(): defaultclock.dt = 0.1*ms G = NeuronGroup(1, 'dv/dt = -v / (10*ms) : 1') net = Network(G) net.run(0.5*ms) # The new dt is not compatible with the previous time but it should not # raise an error because we start a new simulation at time 0 defaultclock.dt = 1*ms G = NeuronGroup(1, 'dv/dt = -v / (10*ms) : 1') net = Network(G) net.run(1*ms)
def test_network_remove(): x = Counter() y = Counter() net = Network(x, y) net.remove(y) net.run(1*ms) assert_equal(x.count, 10) assert_equal(y.count, 0) # the relevance of this test is when we use weakref.proxy objects in # Network.objects, we should be able to add and remove these from # the Network just as much as the original objects for obj in copy.copy(net.objects): net.remove(obj) net.run(1*ms) assert_equal(x.count, 10) assert_equal(y.count, 0)
def test_incorrect_network_use(): '''Test some wrong uses of `Network` and `MagicNetwork`''' assert_raises(TypeError, lambda: Network(name='mynet', anotherkwd='does not exist')) assert_raises(TypeError, lambda: Network('not a BrianObject')) net = Network() assert_raises(TypeError, lambda: net.add('not a BrianObject')) assert_raises(ValueError, lambda: MagicNetwork()) G = NeuronGroup(10, 'v:1') net.add(G) assert_raises(TypeError, lambda: net.remove(object())) assert_raises(MagicError, lambda: magic_network.add(G)) assert_raises(MagicError, lambda: magic_network.remove(G))
def test_network_default_schedule(): net = Network() assert net.schedule == [ 'start', 'groups', 'thresholds', 'synapses', 'resets', 'end' ] # Set the preference and check that the change is taken into account prefs.core.network.default_schedule = list( reversed( ['start', 'groups', 'thresholds', 'synapses', 'resets', 'end'])) assert net.schedule == list( reversed( ['start', 'groups', 'thresholds', 'synapses', 'resets', 'end']))
def test_initialize_simulation_runtime(setup): net, dt, duration = setup start_scope() rts = RuntimeSimulator() assert_raises(TypeError, rts.initialize) rts.initialize(net, var_init=None) assert (isinstance(rts.networks['fit'], Network)) assert_raises(KeyError, rts.initialize, empty_net, None) wrong_net = Network(NeuronGroup(1, model, name='neurons2')) assert_raises(Exception, rts.initialize, wrong_net, None) assert_raises(TypeError, rts.initialize, Network)
def test_initialize_simulation_standalone(setup): start_scope() net, _, _ = setup sas = CPPStandaloneSimulator() assert_raises(TypeError, sas.initialize) assert_raises(TypeError, sas.initialize, net) assert_raises(KeyError, sas.initialize, empty_net, None) wrong_net = Network(NeuronGroup(1, model, name='neurons2')) assert_raises(Exception, sas.initialize, wrong_net, None) sas.initialize(net, var_init=None, name='test') assert (isinstance(sas.networks['test'], Network))
def test_schedule_warning(): previous_device = get_device() from uuid import uuid4 # TestDevice1 supports arbitrary schedules, TestDevice2 does not class TestDevice1(Device): pass class TestDevice2(Device): def __init__(self): super(TestDevice2, self).__init__() self.network_schedule = ['start', 'groups', 'synapses', 'thresholds', 'resets', 'end'] # Unique names are important for getting the warnings again for multiple # runs of the test suite name1 = 'testdevice_' + str(uuid4()) name2 = 'testdevice_' + str(uuid4()) all_devices[name1] = TestDevice1() all_devices[name2] = TestDevice2() set_device(name1) net = Network() # Any schedule should work net.schedule = list(reversed(net.schedule)) with catch_logs() as l: net.run(0*ms) assert len(l) == 0, 'did not expect a warning' set_device(name2) # Using the correct schedule should work net.schedule = ['start', 'groups', 'synapses', 'thresholds', 'resets', 'end'] with catch_logs() as l: net.run(0*ms) assert len(l) == 0, 'did not expect a warning' # Using another (e.g. the default) schedule should raise a warning net.schedule = None with catch_logs() as l: net.run(0*ms) assert len(l) == 1 and l[0][1].endswith('schedule_conflict') set_device(previous_device)
def run_net(traj): """Creates and runs BRIAN network based on the parameters in `traj`.""" eqs = traj.eqs # Create a namespace dictionairy namespace = traj.Net.f_to_dict(short_names=True, fast_access=True) # Create the Neuron Group neuron = NeuronGroup(traj.N, model=eqs, threshold=traj.Vcut, reset=traj.reset, namespace=namespace) neuron.vm = traj.EL neuron.w = traj.a * (neuron.vm - traj.EL) neuron.Vr = linspace(-48.3 * mV, -47.7 * mV, traj.N) # bifurcation parameter # Run the network initially for 100 milliseconds print('Initial Run') net = Network(neuron) net.run(100 * ms, report='text') # we discard the first spikes # Create a Spike Monitor MSpike = SpikeMonitor(neuron) net.add(MSpike) # Create a State Monitor for the membrane voltage, record from neurons 1-3 MStateV = StateMonitor(neuron, variables=['vm'], record=[1, 2, 3]) net.add(MStateV) # Now record for 500 milliseconds print('Measurement run') net.run(500 * ms, report='text') # Add the BRAIN monitors traj.v_standard_result = Brian2MonitorResult traj.f_add_result('SpikeMonitor', MSpike) traj.f_add_result('StateMonitorV', MStateV)
def test_network_schedule_change(): # Check that a changed schedule is taken into account correctly NameLister.updates[:] = [] x = NameLister(name='x', when='thresholds') y = NameLister(name='y', when='resets') net = Network(x, y) net.run(0.3*ms) assert_equal(''.join(NameLister.updates), 'xyxyxy') NameLister.updates[:] = [] net.schedule = ['start', 'groups', 'synapses', 'resets', 'thresholds', 'end'] net.run(0.3*ms) assert_equal(''.join(NameLister.updates), 'yxyxyx')
def test_network_reinit_pre_post_run(): # Check that reinit and before_run and after_run work x = Preparer() net = Network(x) assert_equal(x.did_reinit, False) assert_equal(x.did_pre_run, False) assert_equal(x.did_post_run, False) net.run(1 * ms) assert_equal(x.did_reinit, False) assert_equal(x.did_pre_run, True) assert_equal(x.did_post_run, True) net.reinit() assert_equal(x.did_reinit, True) # Make sure that running with "report" works net.run(1 * ms, report='stdout')
def test_run_simulation_runtime_var_init(setup): _, dt, duration = setup start_scope() neurons = NeuronGroup(1, model2, name='neurons') monitor = StateMonitor(neurons, 'v', record=True, name='statemonitor') net = Network(neurons, monitor) rts = RuntimeSimulator() rts.initialize(net, var_init={'v': -60 * mV}) rts.run(duration, {'gL': 100, 'C': 10}, ['gL', 'C'], iteration=0) v = getattr(rts.statemonitor, 'v') assert_equal(np.shape(v), (1, duration / dt))
def setup_simulator(self, network_name, n_neurons, output_var, param_init, calc_gradient=False, optimize=True, online_error=False, level=1): simulator = setup_fit() namespace = get_full_namespace( { 'input_var': self.input_traces, 'n_traces': self.n_traces }, level=level + 1) if hasattr(self, 't_start'): # OnlineTraceFitter namespace['t_start'] = self.t_start if network_name != 'generate' and self.output_var != 'spikes': namespace['output_var'] = TimedArray(self.output.transpose(), dt=self.dt) neurons = self.setup_neuron_group(n_neurons, namespace, calc_gradient=calc_gradient, optimize=optimize, online_error=online_error) if output_var == 'spikes': monitor = SpikeMonitor(neurons, name='monitor') else: record_vars = [output_var] if calc_gradient: record_vars.extend( [f'S_{output_var}_{p}' for p in self.parameter_names]) monitor = StateMonitor(neurons, record_vars, record=True, name='monitor', dt=self.dt) network = Network(neurons, monitor) if calc_gradient: param_init = dict(param_init) param_init.update( get_sensitivity_init(neurons, self.parameter_names, param_init)) simulator.initialize(network, param_init, name=network_name) return simulator
def test_network_operations(): # test NetworkOperation and network_operation seq = [] def f1(): seq.append('a') op1 = NetworkOperation(f1, when='start', order=1) @network_operation def f2(): seq.append('b') @network_operation(when='end', order=1) def f3(): seq.append('c') # In complex frameworks, network operations might be object methods that # access some common data class Container(object): def __init__(self): self.g1_data = 'B' self.g2_data = 'C' def g1(self): seq.append(self.g1_data) def g2(self): seq.append(self.g2_data) c = Container() c_op1 = NetworkOperation(c.g1) c_op2 = NetworkOperation(c.g2, when='end', order=1) net = Network(op1, f2, f3, c_op1, c_op2) net.run(1 * ms) assert_equal(''.join(seq), 'bBacC' * 10)
def test_network_incorrect_schedule(): # Test that incorrect arguments provided to schedule raise errors net = Network() # net.schedule = object() assert_raises(TypeError, setattr, net, 'schedule', object()) # net.schedule = 1 assert_raises(TypeError, setattr, net, 'schedule', 1) # net.schedule = {'slot1', 'slot2'} assert_raises(TypeError, setattr, net, 'schedule', {'slot1', 'slot2'}) # net.schedule = ['slot', 1] assert_raises(TypeError, setattr, net, 'schedule', ['slot', 1]) # net.schedule = ['start', 'after_start'] assert_raises(ValueError, setattr, net, 'schedule', ['start', 'after_start']) # net.schedule = ['before_start', 'start'] assert_raises(ValueError, setattr, net, 'schedule', ['before_start', 'start'])
def setup(request): dt = 0.1 * ms duration = 10 * ms neurons = NeuronGroup(1, model, name='neurons') monitor = StateMonitor(neurons, 'I', record=True, name='statemonitor') net = Network(neurons, monitor) def fin(): reinit_devices() request.addfinalizer(fin) return net, dt, duration
def test_continuation(): defaultclock.dt = 1*ms G = NeuronGroup(1, 'dv/dt = -v / (10*ms) : 1') G.v = 1 mon = StateMonitor(G, 'v', record=True) net = Network(G, mon) net.run(2*ms) # Run the same simulation but with two runs that use sub-dt run times G2 = NeuronGroup(1, 'dv/dt = -v / (10*ms) : 1') G2.v = 1 mon2 = StateMonitor(G2, 'v', record=True) net2 = Network(G2, mon2) net2.run(0.5*ms) net2.run(1.5*ms) assert_equal(mon.t[:], mon2.t[:]) assert_equal(mon.v[:], mon2.v[:])