def simulate(tau): b2.start_scope() if standalone_mode: b2.get_device().reinit() b2.get_device().activate(build_on_run=False, directory=directory_name) net = b2.Network() P = b2.PoissonGroup(num_inputs, rates=input_rate) G = b2.NeuronGroup(1, eqs, threshold='v>1', reset='v=0', method='euler') S = b2.Synapses(P, G, on_pre='v += weight') S.connect() M = b2.SpikeMonitor(G) net.add(P) net.add(G) net.add(S) net.add(M) net.run(1000 * b2.ms) if standalone_mode: b2.get_device().build(directory=directory_name, compile=True, run=True, debug=False) return M
def main4(): # Incorporation of refractory period bs.start_scope() tau = 10 * bs.ms # the (unless refractory) is necessary # refer to the documentation for more detail eqs = ''' dv/dt = (1-v)/tau : 1 (unless refractory) ''' equation = bs.Equations(eqs) # conditions for spiking models threshold = 'v>0.8' reset = 'v = -0.8' refractory = 5 * bs.ms G = bs.NeuronGroup(1, eqs, threshold=threshold, reset=reset, method='exact', refractory=refractory) state_monitor = bs.StateMonitor(G, 'v', record=0) spike_monitor = bs.SpikeMonitor(G) bs.run(50 * bs.ms) plt.plot(state_monitor.t / bs.ms, state_monitor.v[0]) plt.xlabel('Time (ms)') plt.ylabel('v') plt.show()
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 main1(): # adding different weights per synapse # ex0 distance-dependent connectivity function= # important for a lot neurons that have weaker inhibitory/excitatory connections as the distances get wider bs.start_scope() n_neurons = 30 neuron_spacing = 50 * bs.umetre width = n_neurons / 4.0 * neuron_spacing G = bs.NeuronGroup(n_neurons, 'x:metre') G.x = 'i*neuron_spacing' # All synapses are connected (excluding self-connections) S = bs.Synapses(G, G, 'w:1') S.connect(condition='i!=j') # basically, any variable you use in the definition of equations is usable as an actual variable in code and vice versa # therefore, even if the variable width is labelled as not being used, it actually is lol S.w = 'exp(-(x_pre-x_post)**2/(2*width**2))' # visualise_connectivity(S) plt.clf() plt.scatter(S.x_pre / bs.um, S.x_post / bs.um, S.w * 20) plt.xlabel('source neuron position (um)') plt.ylabel('Target neuron position (um)') plt.show()
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 main8(): # using generator syntax to create connections bs.start_scope() n_neurons = 10 G = bs.NeuronGroup(n_neurons, 'v:1') S = bs.Synapses(G, G) """ i : int, ndarray of int, optional The presynaptic neuron indices (in the form of an index or an array of indices). Must be combined with ``j`` argument. j : int, ndarray of int, str, optional The postsynaptic neuron indices. It can be an index or array of indices if combined with the ``i`` argument, or it can be a string generator expression. """ # the above is the reason why j="i" works but not i = "j" # only j can take in string. i has to take in int, or ndarray of int S.connect(j='i', skip_if_invalid=True) # You can also do it the following way # S.connect(condition = 'i==j', skip_if_invalid=True) visualise_connectivity(S)
def main1(): bs.start_scope() tau = 10 * bs.ms # equations must end with : unit # unit is the SI unit of that variable # the unit is 1 since the number "1" is unitless # v represents voltage, but we just keep it unitless for simplicity # 1/s not part of the unit since the unit represents the unit of the variable itself # rather than the unit of the equation eqs = ''' dv/dt = (1-v)/tau: 1 ''' G = bs.NeuronGroup(1, model=eqs, method='exact') # record : bool, sequence of ints # Which indices to record, nothing is recorded for ``False``, # everything is recorded for ``True`` (warning: may use a great deal of # memory), or a specified subset of indices. M = bs.StateMonitor(G, 'v', record=0) print('Before v = %s' % G.v[0]) bs.run(100 * bs.ms) # runs the simulation for 100ms print('After v = %s' % G.v[0]) plt.plot(M.t / bs.ms, M.v[0]) plt.xlabel('Time (ms)') plt.ylabel('v') plt.show()
def main3(): # Adding Spikes bs.start_scope() tau = 10 * bs.ms eqs = ''' dv/dt = (1-v)/tau : 1 ''' # conditions for spiking models threshold = 'v>0.8' reset = 'v = -0.8' G = bs.NeuronGroup(1, eqs, threshold=threshold, reset=reset, method='exact') M = bs.StateMonitor(G, 'v', record=0) bs.run(50 * bs.ms) plt.plot(M.t / bs.ms, M.v[0]) plt.xlabel('Time (ms)') plt.ylabel('v') plt.show() # you can also add spike monitor spike_monitor = bs.SpikeMonitor(G) bs.run(50 * bs.ms) print(f"Spike Times: {spike_monitor.t[:]}")
def test_poissoninput(): """ Test collect_PoissonInput() """ # test 1 start_scope() v_th = 1 * volt grp = NeuronGroup(10, 'dv/dt = (v_th - v)/(10*ms) :volt', method='euler', threshold='v>100*mV', reset='v=0*mV') poi = PoissonInput(grp, 'v', 10, 1*Hz, 'v_th * rand() + 1*mV') poi_dict = collect_PoissonInput(poi, get_local_namespace(0)) assert poi_dict['target'] == grp.name assert poi_dict['rate'] == 1*Hz assert poi_dict['N'] == 10 assert poi_dict['target_var'] == 'v' assert poi_dict['when'] == poi.when assert poi_dict['order'] == poi.order assert poi_dict['clock'] == poi.clock.dt assert poi_dict['identifiers']['v_th'] == v_th # test 2 grp2 = NeuronGroup(10, 'dv_1_2_3/dt = (v_th - v_1_2_3)/(10*ms) :volt', method='euler', threshold='v_1_2_3>v_th', reset='v_1_2_3=-v_th') poi2 = PoissonInput(grp2, 'v_1_2_3', 0, 0*Hz, v_th) poi_dict = collect_PoissonInput(poi2, get_local_namespace(0)) assert poi_dict['target'] == grp2.name assert poi_dict['rate'] == 0*Hz assert poi_dict['N'] == 0 assert poi_dict['target_var'] == 'v_1_2_3' with pytest.raises(KeyError): poi_dict['identifiers']
def test_custom_events_neurongroup(): start_scope() grp = NeuronGroup(10, 'dvar/dt = (100 - var) / tau_n : 1', events={'test_event': 'var > 70'}, method='exact') tau_n = 10 * ms grp.thresholder['test_event'].clock.dt = 10 * ms neuron_dict = collect_NeuronGroup(grp, get_local_namespace(0)) custom_event = neuron_dict['events']['test_event'] thresholder = custom_event['threshold'] assert thresholder['code'] == 'var > 70' assert thresholder['when'] == grp.thresholder['test_event'].when assert thresholder['order'] == grp.thresholder['test_event'].order assert thresholder['dt'] == 10 * ms with pytest.raises(KeyError): neuron_dict['events']['spike'] custom_event['reset'] custom_event['refractory'] # check with reset grp.run_on_event('test_event', 'var = -10') neuron_dict = collect_NeuronGroup(grp, get_local_namespace(0)) custom_event = neuron_dict['events']['test_event'] resetter = custom_event['reset'] assert resetter['code'] == 'var = -10' assert resetter['when'] == grp.resetter['test_event'].when assert resetter['order'] == grp.resetter['test_event'].order assert resetter['dt'] == thresholder['dt']
def simulate_Thl_cell_fig3(par, par_sim): num = par_sim['num'] i_sensory_motor = par_sim['I_sm'] # b2.set_device('cpp_standalone') b2.start_scope() eqs = b2.Equations(''' minfthl = 1/(1+exp(-(vt-thtmthl*mV)/(sigmthl*mV))): 1 hinfthl = 1/(1+exp((vt-thththl*mV)/(sighthl*mV))): 1 pinfthl = 1/(1+exp(-(vt-thtpthl*mV)/(sigpthl*mV))) :1 rinfthl = 1/(1+exp((vt-thtrthl*mV)/(sigrthl*mV))) :1 ahthl = ah0thl*exp(-(vt-thtahthl*mV)/(sigahthl*mV)) :1 bhthl = bh0thl/(1+exp(-(vt-thtbhthl*mV)/(sigbhthl*mV))) :1 tauhthl = 1/(ahthl+bhthl) *ms :second taurthl = taur0thl+taur1thl*exp(-(vt-thtrtauthl*mV)/(sigrtauthl*mV)) :second ilthl=glthl*(vt-vlthl):amp inathl=gnathl*minfthl*minfthl*minfthl*hthl*(vt-vnathl) :amp ikthl=gkthl*((0.75*(1-hthl))**4)*(vt-vkthl) :amp itthl=gtthl*pinfthl*pinfthl*rthl*(vt-vtthl) :amp iextthl:amp tmp_thl1 = sin(2*pi*(t-dsmthl)/tmsmthl) :1 tmp_thl2 = sin(2*pi*(t-dsmthl+wsmthl)/tmsmthl) :1 ym_thl1=1/(1+exp(-tmp_thl1/sigym)):1 ym_thl2=1/(1+exp(-tmp_thl2/sigym)):1 ithl_sm=imsmthl*ym_thl1*(1-ym_thl2) :amp membrane_Ithl = -(ilthl+inathl+ikthl+itthl)+iextthl+ithl_sm:amp drthl/dt=phirthl*(rinfthl-rthl)/taurthl :1 dhthl/dt=phihthl*(hinfthl-hthl)/tauhthl :1 dvt/dt = membrane_Ithl/cmthl : volt ''') neuron = b2.NeuronGroup( num, eqs, method=par_sim['integration_method'], dt=par_sim['dt'], threshold='vt>-55*mV', refractory='vt>-55*mV', namespace=par, ) neuron.vt = par['v0'] neuron.hthl = "hinfthl" neuron.rthl = "rinfthl" neuron.iextthl = par['iext'] state_monitor = b2.StateMonitor(neuron, ["vt", "ithl_sm"], record=True) net = b2.Network(neuron) net.add(state_monitor) net.run(par_sim['simulation_time']) return state_monitor
def echo_spike(p, tStim, tTot): start_scope() prefs.codegen.target = "numpy" ################################ # Compute properties ################################ dvInpSpike = p['nu_DV'] # Voltage increase per noise spike dvExcSpike = p['LIF_DV'] # Voltage increase per lateral spike # dvExcSpike = p['LIF_T_0'] / (1.0 * p['N'] * p['p_conn']) # Voltage increase per lateral spike print("typical spike threshold", p['LIF_T_0']) print("typical potential change per noise spike", dvInpSpike) print("typical potential change per lateral spike", dvExcSpike) ################################ # Create input population ################################ nTStimPost = int(tTot / tStim) - 1 # After input switched off, 0-input will be repeated nTStimPost*tStim timesteps patternInp = (np.random.uniform(0, 1, p['N']) < p['nu_p']).astype(int) pattern0 = np.zeros(p['N']) rates_all = np.array([patternInp] + [pattern0]*nTStimPost) * p['nu_FREQ'] rateTimedArray = TimedArray(rates_all, dt=tStim) gInp = PoissonGroup(p['N'], rates="rateTimedArray(t, i)") # gInp = PoissonGroup(p['N'], p['nu_FREQ']) ################################ # Create reservoir population ################################ gExc = brian2wrapper.NeuronGroupLIF(p['N'], p['LIF_V_0'], p['LIF_T_0'], p['LIF_V_TAU']) ################################ # Create synapses ################################ sInpExc = Synapses(gInp, gExc, on_pre='v_post += dvInpSpike', method='exact') sExcExc = Synapses(gExc, gExc, on_pre='v_post += dvExcSpike', method='exact') ################################ # Connect synapses ################################ # * Input and LIF one-to-one # * LIF neurons to each other sparsely sInpExc.connect(j='i') sExcExc.connect(p=p['p_conn']) ################################ # Init Monitors ################################ #spikemonInp = SpikeMonitor(gInp) spikemonExc = SpikeMonitor(gExc) ################################ # Run simulation ################################ run(tTot) return np.array(spikemonExc.i), np.array(spikemonExc.t)
def test_run_simulation_runtime(setup): net, dt, duration = setup start_scope() rts = RuntimeSimulator() rts.initialize(net, var_init=None) rts.run(duration, {'g': 100, 'E': 10}, ['g', 'E']) I = getattr(rts.networks['fit']['monitor'], 'I') assert_equal(np.shape(I), (1, duration / dt))
def main6(): # connecting only the neighbouring neurons bs.start_scope() n_neurons = 10 G = bs.NeuronGroup(n_neurons, 'v:1') S = bs.Synapses(G, G) # connect only if the neuron is less than 4 spaces and the neuron index isnt the same S.connect(condition='abs(i-j)<4 and i!=j') visualise_connectivity(S)
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_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 main7(): # using generator syntax to create connections bs.start_scope() n_neurons = 10 G = bs.NeuronGroup(n_neurons, 'v:1') S = bs.Synapses(G, G) # connect only if the neuron is less than 4 spaces and the neuron index isnt the same # skip in invalid is needed here since on the edge connections, the i+4 goes over bound and causes error S.connect(j='k for k in range(i-3, i+4) if i != k', skip_if_invalid=True) visualise_connectivity(S)
def main4(plot=True): # what if we want to keep the input spike exactly the same throughout different taus? # Solution: We run PoissonGroup once, store all the spikes, and use the stored spikes across the multiple runs bs.start_scope() num_inputs = 100 input_rate = 10 * bs.Hz w = 0.1 tau_range = bs.linspace(1, 10, 30) * bs.ms output_rates = [] P = bs.PoissonGroup(num_inputs, rates=input_rate) p_monitor = bs.SpikeMonitor(P) one_second = 1 * bs.second """ Note that in the code above, we created Network objects. The reason is that in the loop, if we just called run it would try to simulate all the objects, including the Poisson neurons P, and we only want to run that once. We use Network to specify explicitly which objects we want to include. """ net = bs.Network(P, p_monitor) net.run(one_second) # keeps a copy of the spikes that are generated by the PoissonGroup during that explicit run earlier spikes_i = p_monitor.i spikes_t = p_monitor.t # Construct network that we run each time sgg = bs.SpikeGeneratorGroup(num_inputs, spikes_i, spikes_t) eqs = ''' dv/dt = -v/tau : 1 ''' G = bs.NeuronGroup(1, eqs, threshold='v>1', reset='v=0', method='exact') S = bs.Synapses(sgg, G, on_pre='v += w') S.connect() # fully connected network g_monitor = bs.SpikeMonitor(G) # store the current state of the network net = bs.Network(sgg, G, S, g_monitor) net.store() for tau in tau_range: net.restore() net.run(one_second) output_rates.append(g_monitor.num_spikes / bs.second) if plot: plt.clf() plt.plot(tau_range / bs.ms, output_rates) plt.xlabel(r'$\tau$ (ms)') plt.ylabel('Firing Rate (spikes/s)') # there is much less noise compared to before where we used different PoissonGroup everytime plt.show()
def test_magic_scope(): ''' Check that `start_scope` works as expected. ''' G1 = NeuronGroup(1, 'v:1', name='G1') G2 = NeuronGroup(1, 'v:1', name='G2') objs1 = {obj.name for obj in collect()} start_scope() G3 = NeuronGroup(1, 'v:1', name='G3') G4 = NeuronGroup(1, 'v:1', name='G4') objs2 = {obj.name for obj in collect()} assert objs1=={'G1', 'G2'} assert objs2=={'G3', 'G4'}
def main5(): # the effect of probability in connections bs.start_scope() n_neurons = 10 G = bs.NeuronGroup(n_neurons, model='v:1') for p in [0.1, 0.5, 1.0]: S = bs.Synapses(G, G) # connect neurons that do not have the same index with probability p S.connect(condition='i!=j', p=p) visualise_connectivity(S) plt.suptitle('p = ' + str(p))
def main2(): # setting synaptic weight bs.start_scope() n_neurons = 3 eqs = ''' dv/dt = (I-v)/tau : 1 (unless refractory) I : 1 tau: second ''' threshold = 'v>1' reset = 'v = 0' refractory = 10 * bs.ms G = bs.NeuronGroup(N=n_neurons, model=eqs, threshold=threshold, reset=reset, method='exact', refractory=refractory) G.I = [2, 0, 0] # represents the I in eqs # driving current should be bigger than the threshold, otherwise it wont spike at all # I = 0 means that the voltage wont change since there is no driving current G.tau = [10, 100, 100] * bs.ms # represents the tau in eqs # unlike last time, the tau is defined with the neuron so we see the effects of different values # model : `str`, `Equations`, optional # The model equations for the synapses. # you need to set this as model= in Synapses in order to incorporate weight synapse_model = 'w : 1' # So in total, what this model says is that whenever two neurons in G are connected by a synapse, # when the source neuron fires a spike the target neuron will have its value of v increased by 0.2. S = bs.Synapses(source=G, target=G, model=synapse_model, on_pre='v_post += w') S.connect(i=0, j=[1, 2]) # So this will give a synaptic connection from 0 to 1 with weight 0.2=0.2*1 and from 0 to 2 with weight 0.4=0.2*2. S.w = 'j*0.2' state_monitor = bs.StateMonitor(G, 'v', record=True) bs.run(100 * bs.ms) plt.plot(state_monitor.t / bs.ms, state_monitor.v[0], label='Neuron 0') plt.plot(state_monitor.t / bs.ms, state_monitor.v[1], label='Neuron 1') plt.plot(state_monitor.t / bs.ms, state_monitor.v[2], label='Neuron 2') plt.xlabel('Time (ms)') plt.ylabel('v') plt.legend() plt.show()
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_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 main1(): bs.start_scope() # Parameters area = 20000 * bs.umetre**2 Cm = 1 * bs.ufarad * bs.cm**-2 * area gl = 5e-5 * bs.siemens * bs.cm**-2 * area El = -65 * bs.mV EK = -90 * bs.mV ENa = 50 * bs.mV g_na = 100 * bs.msiemens * bs.cm**-2 * area g_kd = 30 * bs.msiemens * bs.cm**-2 * area VT = -63 * bs.mV # HH stands for Hudgkin-Huxley eqs_HH = ''' dv/dt = (gl*(El-v) - g_na*(m*m*m)*h*(v-ENa) - g_kd*(n*n*n*n)*(v-EK) + I)/Cm : volt dm/dt = 0.32*(mV**-1)*(13.*mV-v+VT)/ (exp((13.*mV-v+VT)/(4.*mV))-1.)/ms*(1-m)-0.28*(mV**-1)*(v-VT-40.*mV)/ (exp((v-VT-40.*mV)/(5.*mV))-1.)/ms*m : 1 dn/dt = 0.032*(mV**-1)*(15.*mV-v+VT)/ (exp((15.*mV-v+VT)/(5.*mV))-1.)/ms*(1.-n)-.5*exp((10.*mV-v+VT)/(40.*mV))/ms*n : 1 dh/dt = 0.128*exp((17.*mV-v+VT)/(18.*mV))/ms*(1.-h)-4./(1+exp((40.*mV-v+VT)/(5.*mV)))/ms*h : 1 I : amp ''' group = bs.NeuronGroup(1, eqs_HH, threshold='v > -40*mV', refractory='v > -40*mV', method='exponential_euler') group.v = El state_monitor = bs.StateMonitor(group, 'v', record=True) spike_monitor = bs.SpikeMonitor(group, variables='v') plt.figure(figsize=(9, 4)) for l in range(5): group.I = bs.rand() * 50 * bs.nA bs.run(10 * bs.ms) bs.axvline(l * 10, ls='--', c='k') bs.axhline(El / bs.mV, ls='-', c='lightgray', lw=3) state_time = state_monitor.t spike_time = spike_monitor.t plt.plot(state_time / bs.ms, spike_monitor.v[0] / bs.mV, '-b') plt.plot(spike_time / bs.ms, spike_monitor.v / bs.mV, 'ob') plt.xlabel('Time (ms)') plt.ylabel('v (mV)') plt.show()
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 main3(): # introducing delay bs.start_scope() n_neurons = 3 eqs = ''' dv/dt = (I-v)/tau : 1 (unless refractory) I : 1 tau: second ''' threshold = 'v>1' reset = 'v = 0' refractory = 10 * bs.ms G = bs.NeuronGroup(N=n_neurons, model=eqs, threshold=threshold, reset=reset, method='exact', refractory=refractory) G.I = [2, 0, 0] # represents the I in eqs # driving current should be bigger than the threshold, otherwise it wont spike at all # I = 0 means that the voltage wont change since there is no driving current G.tau = [10, 100, 100] * bs.ms # represents the tau in eqs # unlike last time, the tau is defined with the neuron so we see the effects of different values synapse_model = 'w : 1' # So in total, what this model says is that whenever two neurons in G are connected by a synapse, # when the source neuron fires a spike the target neuron will have its value of v increased by 0.2. S = bs.Synapses(source=G, target=G, model=synapse_model, on_pre='v_post += w') S.connect(i=0, j=[1, 2]) S.w = 'j*0.2' S.delay = 'j*2*ms' state_monitor = bs.StateMonitor(G, 'v', record=True) bs.run(100 * bs.ms) plt.plot(state_monitor.t / bs.ms, state_monitor.v[0], label='Neuron 0') plt.plot(state_monitor.t / bs.ms, state_monitor.v[1], label='Neuron 1') plt.plot(state_monitor.t / bs.ms, state_monitor.v[2], label='Neuron 2') plt.xlabel('Time (ms)') plt.ylabel('v') plt.legend() plt.show()
def main4(): # more complex connectivity bs.start_scope() n_neurons = 3 tau = 100 * bs.ms eqs = ''' dv/dt = (I-v)/tau : 1 (unless refractory) I : 1 ''' threshold = 'v>1' reset = 'v = 0' refractory = 10 * bs.ms G = bs.NeuronGroup(N=n_neurons, model=eqs, threshold=threshold, reset=reset, method='exact', refractory=refractory) G.I = [2, 0, 0] synapse_model = 'w : 1' # p : float, str, optional # The probability to create ``n`` synapses wherever the ``condition`` # evaluates to true. Cannot be used with generator syntax for ``j``. S = bs.Synapses(source=G, target=G, model=synapse_model, on_pre='v_post += w') S.connect(condition='i!=j', p=0.5) S.w = 'j*0.2' state_monitor = bs.StateMonitor(G, 'v', record=True) bs.run(100 * bs.ms) plt.plot(state_monitor.t / bs.ms, state_monitor.v[0], label='Neuron 0') plt.plot(state_monitor.t / bs.ms, state_monitor.v[1], label='Neuron 1') plt.plot(state_monitor.t / bs.ms, state_monitor.v[2], label='Neuron 2') plt.xlabel('Time (ms)') plt.ylabel('v') plt.legend() plt.show() visualise_connectivity(S=S)
def run_simulation(tau_I): br.start_scope() tau_E = 10*br.ms #tau_I = 10*br.ms M_EE = 1.25 M_EI = -1 M_IE = 1 M_II = 0 gamma_E = -10*br.Hz gamma_I = 10*br.Hz equ1 = ''' dv_E/dt = (-v_E + (M_EE*v_E + M_EI*v_I - gamma_E))/tau_E : Hz v_I : Hz (linked) ''' equ2 = ''' dv_I/dt = (-v_I + (M_IE*v_E + M_II*v_I - gamma_I))/tau_I : Hz v_E : Hz (linked) ''' G1 = br.NeuronGroup(1, equ1, method = 'euler') G2 = br.NeuronGroup(1, equ2, method = 'euler') G1.v_E = 50 *br.Hz G2.v_I = 50 *br.Hz G2.v_E = br.linked_var(G1, 'v_E' ) G1.v_I = br.linked_var(G2, 'v_I' ) statemon1 = br.StateMonitor(G1, ['v_I', 'v_E'], record=True) #statemon2 = br.StateMonitor(G2, ['dv_I/dt', 'dv_E/dt'], record=True) br.run(1000*br.ms) return statemon1
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 main1(): # checking effect of synaptic connectipn bs.start_scope() n_neurons = 2 eqs = ''' dv/dt = (I-v)/tau : 1 (unless refractory) I : 1 tau: second ''' threshold = 'v>1' reset = 'v = 0' refractory = 10 * bs.ms G = bs.NeuronGroup(N=n_neurons, model=eqs, threshold=threshold, reset=reset, method='exact', refractory=refractory) G.I = [2, 0] # represents the I in eqs # driving current should be bigger than the threshold, otherwise it wont spike at all # I = 0 means that the voltage wont change since there is no driving current G.tau = [10, 100] * bs.ms # represents the tau in eqs # unlike last time, the tau is defined with the neuron so we see the effects of different values # So in total, what this model says is that whenever two neurons in G are connected by a synapse, # when the source neuron fires a spike the target neuron will have its value of v increased by 0.2. S = bs.Synapses(source=G, target=G, on_pre='v_post += 0.2') # calling just S.connect() without any parameters just connects every source neuron with every target neuron # fully connected S.connect(i=0, j=1) visualise_connectivity(S) state_monitor = bs.StateMonitor(G, 'v', record=True) bs.run(100 * bs.ms) plt.plot(state_monitor.t / bs.ms, state_monitor.v[0], label='Neuron 0') plt.plot(state_monitor.t / bs.ms, state_monitor.v[1], label='Neuron 1') plt.xlabel('Time (ms)') plt.ylabel('v') plt.legend() plt.show()
def main(): # pragma: no cover from brian2 import start_scope,mvolt,ms,NeuronGroup,StateMonitor,run import matplotlib.pyplot as plt import neo import quantities as pq start_scope() # Izhikevich neuron parameters. a = 0.02/ms b = 0.2/ms c = -65*mvolt d = 6*mvolt/ms I = 4*mvolt/ms # Standard Izhikevich neuron equations. eqs = ''' dv/dt = 0.04*v**2/(ms*mvolt) + (5/ms)*v + 140*mvolt/ms - u + I : volt du/dt = a*((b*v) - u) : volt/second ''' reset = ''' v = c u += d ''' # Setup and run simulation. G = NeuronGroup(1, eqs, threshold='v>30*mvolt', reset='v = -70*mvolt') G.v = -65*mvolt G.u = b*G.v M = StateMonitor(G, 'v', record=True) run(300*ms) # Store results in neo format. vm = neo.core.AnalogSignal(M.v[0], units=pq.V, sampling_period=0.1*pq.ms) # Plot results. plt.figure() plt.plot(vm.times*1000,vm*1000) # Plot mV and ms instead of V and s. plt.xlabel('Time (ms)') plt.ylabel('mv') # Save results. iom = neo.io.PyNNNumpyIO('spike_extraction_test_data') block = neo.core.Block() segment = neo.core.Segment() segment.analogsignals.append(vm) block.segments.append(segment) iom.write(block) # Load results. iom2 = neo.io.PyNNNumpyIO('spike_extraction_test_data.npz') data = iom2.read() vm = data[0].segments[0].analogsignals[0] # Plot results. # The two figures should match. plt.figure() plt.plot(vm.times*1000,vm*1000) # Plot mV and ms instead of V and s. plt.xlabel('Time (ms)') plt.ylabel('mv')