Brian2 is an improved and partly rewritten version of Brian, the spiking neural network simulator (see http://briansimulator.org). For the documentation, see http://brian2.readthedocs.org
float (for a scalar value) or np.array (for an array). See https://brian2.readthedocs.io/en/stable/user/units.html#removing-units
index to a random number between 0 and 100 (i.e. up to 99), you can use S.index = 'int(rand()*100)', but this will lead to some repeated and some missing values. To not repeat indices, you'll have to use numpy instead of Brian's string expression framework. E.g., S.index = np.choice(100, replace=False, size=100).
When I copied-paste the code at the end of the Brian tutorial part 1, there was an error at this line
x = hist(spikemon.t/ms, 100, histtype='stepfilled', facecolor='k', weights=list(ones(len(spikemon))/(N*defaultclock.dt)))
it said "ValueError: weights should have the same shape as x"
7 replies
For a <class 'brian2.units.fundamentalunits.Quantity'>, what is the best way to strip the unit and just get the number. For example: 9. ms and I just need to get 9.
You can use, float(9*ms) to get the numerical part, but it returns in SI unit For eg. 0.009
1 reply
I initialized my weights with 'rand()' after connecting synapses.
my question is that after first run it will continue with new weights which have changed with STDP rule or it reset to weight initialization for next run?
run(...) statements, then the second one will continue where the previous simulation stopped. This includes all variables such as synaptic weights. Statements like S.w = 'rand()' are only executed at the point in the code where they are written. They do not get automatically re-executed for a second run.
how about when I import my weights as initialization instead of rand()?
Not sure I understand, you mean when you initialize weights with some concrete values S.w = some_values ? This does not change anything, this assignment is executed only once like any other assignment.
Hi @RNaderi . Would you mind asking this question on https://brian.discourse.group ? It's not a simple answer, and I think others could benefit from it. Thanks!
for sure. I thought it would be short. That was why I asked here. Thank you.
clk.dt_ is not a private attribute (that would be clk._dt), the ..._ syntax is just the value without the units, and normally setting clk.dt_ = ... or clk.dt = 0.00001 or clk.dt = 0.001*ms should do the exact same thing. That value seems to be a bit on the tiny side, though.
Network object. Something like this should work:# .. define network
p = PoissonInput(...)
net = Network(collect()) # create network with all objects
net.run(...) # run first simulation
net.remove(p) # remove previous PoissonInput
p = PoissonInput(...) # create new PoissonInput
net.add(p) # add the new object to the network
net.run(...) # run new simulationNetwork object, an alternative would be to create all your inputs in the beginning, but only make one of them active at a time. Something along the lines of# ... define network
p1 = PoissonInput(...)
p2 = PoissonInput(...)
p2.active = False # switch off second input
run(...)
# switch from first to second input
p1.active = False
p2.active = True
run(...)Since I don't have deep understanding of Poisson input , I wanted to ask you if I generate 2 PoissonInput with the same rate(with the same initialization), will the result be the same ? I mean in terms of correlation of input spikes.
Note sure I undertand. The results will not be exactly the same (different random numbers), but the statistics are the same in both cases. The spikes are uncorrelated.
If you remove/add elements to an existing network as in my example, everything else in the network is unaffected. Synaptic weights, state variables, etc. are all unchanged, and the simulation continues where it left off. I did not think of it earlier, but if you want to keep your previous approach without creating a
Networkobject, an alternative would be to create all your inputs in the beginning, but only make one of them active at a time. Something along the lines of# ... define network p1 = PoissonInput(...) p2 = PoissonInput(...) p2.active = False # switch off second input run(...) # switch from first to second input p1.active = False p2.active = True run(...)
How interesting. Thank you very much.
Since I don't have deep understanding of Poisson input , I wanted to ask you if I generate 2 PoissonInput with the same rate(with the same initialization), will the result be the same ? I mean in terms of correlation of input spikes.
Note sure I undertand. The results will not be exactly the same (different random numbers), but the statistics are the same in both cases. The spikes are uncorrelated.
Is there any way to monitor poisoninput in the way that be used for PoissonGroup (SpikeMonitor(Poissongroup)) ?
Ah sorry, I did not think about that. In cases like this you have to be more explicit about what the components of your model are, by creating a
Networkobject. Something like this should work:# .. define network p = PoissonInput(...) net = Network(collect()) # create network with all objects net.run(...) # run first simulation net.remove(p) # remove previous PoissonInput p = PoissonInput(...) # create new PoissonInput net.add(p) # add the new object to the network net.run(...) # run new simulation
when I am using this way, after the first run I recieve this message : "neurongroup has already been run in the context of another network. Use add/remove to change the objects in a simulated network instead of creating a new one." should I also remove neuronGroup each time?
from brian2 import *
G = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1')
p1 = PoissonInput(G, 'v', 10, 50*Hz, 0.1)
state_mon = StateMonitor(G, 'v', record=0)
net = Network(collect())
net.run(100*ms)
net.remove(p1)
p2 = PoissonInput(G, 'v', 10, 5*Hz, 0.1)
net.add(p2)
net.run(100*ms)
plt.plot(state_mon.t/ms, state_mon.v[0])
plt.show()Is there any way to monitor poisoninput in the way that be used for PoissonGroup (SpikeMonitor(Poissongroup)) ?
It is not as straightforward, since it does not generate any individual events/spikes, but instead determines the total number of spikes for each time step (this is much faster if you have several neurons, i.e. N >> 1. If this is not the case, then rather use a PoissonGroup). If the PoissonInput is the only thing that updates the target variable (g_e in your earlier example), then you can use a StateMonitor to observe that variable and see the effect of PoissonInput. By comparing the value before and after the update, you get its effect. Here's how to update my earlier example to plot the PoissonInput contribution:
from brian2 import *
G = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1')
p1 = PoissonInput(G, 'v', 10, 50*Hz, 0.1)
state_mon = StateMonitor(G, 'v', record=0)
poisson_mon_before = StateMonitor(G, 'v', record=0, when='before_synapses')
poisson_mon_after = StateMonitor(G, 'v', record=0, when='after_synapses')
net = Network(collect())
net.run(100*ms)
net.remove(p1)
p2 = PoissonInput(G, 'v', 10, 5*Hz, 0.1)
net.add(p2)
net.run(100*ms)
fig, (ax_top, ax_bottom) = plt.subplots(2, 1, sharex=True)
ax_top.plot(state_mon.t/ms, state_mon.v[0])
ax_bottom.plot(poisson_mon_before.t/ms, poisson_mon_after.v[0] - poisson_mon_before.v[0])
plt.show()
PoissonInput contribution.
Synapses object, then you have to use when='synapses' for the StateMonitors, and use the order argument of the StateMonitors and the PoissonInput to make sure that the order of operations is : first monitor → PoissonInput → second monitor (see https://brian2.readthedocs.io/en/stable/user/running.html#scheduling)
inh_neurons = neurons[N_e:] , I want to give 2 different "v_thr" for excitatory and inhibitory neurons ( N=N_e+N_i ). how can I define V>v_thr as input parameter in neuron equation?
I would be grateful if you could take a look at my issue in this link : https://brian.discourse.group/t/issues-with-spikegeneratorgroup/626/1
I've just solved this problem with adding an offset over run to spike_times of each input.