PROGRAMMING TUTORIAL 4: SYNAPSES IN BRIAN2

Size: px

Start display at page:

Download "PROGRAMMING TUTORIAL 4: SYNAPSES IN BRIAN2"

Francine Spencer
5 years ago
Views:

1 PROGRAMMING TUTORIAL 4: SYNAPSES IN BRIAN2 FABIAN SOTO OCTOBER 14, 2016

2 GETTING STARTED Open a jupyter notebook Include the standard lines to import tools for your simulation:

3 # import packages from brian2 import * import numpy as np import pylab as plt # allow inline plotting in the notebook %matplotlib inline # start scope for this brian2 simulation start_scope()

4 1. CREATE TWO SEPARATE INPUT ARRAYS For the first time, we will create a model with more than one neuron We want to control input currents manually injected into each neuron As before, the input will be a numpy array transformed to TimeArray However, now we will have to create two arrays instead of one Our simulations will take 200 ms We will create a matrix of zeros, with two columns and 200 rows:

5 # create 200x2 array of zeros # each column in this array will be input for a different neuron input_current = np.zeros((200,2)) Now we can replace any number in the array by some input To access the full array of inputs for neuron #1, indexed by i=0, we write input_current[:,0] The : means all rows, whereas the 0 means first column To access the input to neuron #1 at, we write input_current[99,0] We use the same syntax to set the input to a given value For example, we can write input_current[99,0]=200

6 We will give manual input only to the presynaptic neuron (indexed by 0) For now, let s place an input of 200pA that starts at t=51 and ends at t=65 We also convert our numpy array to TimedArray:

7 # place an input of 200 pa to the first neuron (with index 0) # starting at t=51 and ending at t=65 input_current[50:65,0] = 200 # convert numpy array to timed array input_current = TimedArray(input_current*pamp, dt=1*ms) With this, we have that the presynaptic neuron (indexed by 0) will receive a manual input On the other hand, the manual input for the postsynaptic neuron (indexed by 1) was set to zero throughout the simulation

8 2. DEFINE MODEL PARAMETERS We will model two neurons, one presynaptic and one postsynaptic For now, we ll use LIF neurons The input to the postsynaptic neuron will be a synaptic current: Thus, the equation for the LIF neuron will be: Remember: EPSCs are negative by convention, whereas IPSC are positive by convention Besides this, when, we reset to Create a new cell and define the model parameters:

9 # define parameters of the LIF model R = 100*Mohm # membrane resistance tau = 10 * ms # membrane time constant thr = -50 * mv # spike threshold u_rest = -65 * mv # resting potential u_r = -70 * mv # reset potential

10 The PSC is obtained from the synaptic conductance the following equation: using Here, is the equilibrium potential for the channel producing the PSC (e.g., AMPA, GABA, etc.) To model the synaptic conductance, we use the simple model with a jump and exponential decay: Create a new cell and define the parameters in this model:

11 # define parameters of the synapse model E_syn = 0 * mv # equilibrium potential of the channel tau_decay = 2 * ms # speed of NT unbinding g_jump = 10*nsiemens # jump in conductivity after a presynaptic spike

12 3. DEFINE MODEL EQUATIONS We have 2 differential equations, for changes in and We also have to include Ohm s law to convert from to Finally, we must define the manual input current in our equation string, as before So we define a string of equations with four lines:

13 # define equation for the LIF model # and equation for the synapse model eqs = ''' du/dt = ( -(u - u_rest) + R*I - R*I_syn ) / tau : volt I = input_current(t,i) : amp I_syn = g_syn*(u - E_syn): amp dg_syn/dt = -g_syn / tau_decay : siemens '''

14 4. CREATE THE MODEL The LIF neuron model is created as before, using the function NeuronGroup The only difference is that we now will ask Brian2 to create 2 LIF neurons rather than 1 Create a new cell and enter the following:

15 # create neuron group LIF = NeuronGroup(2, eqs, threshold='u>thr', reset='u=u_r') Note how now the first input to NeuronGroup is 2 instead of 1 We also need to set the membrane potential of both neurons to The initial value of can be set using LIF.u Because now there are two neurons LIF.u has two elements: LIF.u[0] and LIF.u[1] We can set them both to the same value by using :

16 # set membrane to resting potential LIF.u[:] = u_rest With this we are all done with the neuron model Now we need to create a synapse model to connect the neurons in our LIF model In Brian2, we use the function Synapses to do this, which receives as input one or two neuron groups For now, we use only one neuron group, LIF Synapses also allows you to indicate what should happen with a variable when there is a presynaptic spike, by using pre= followed by a string with an expression to be evaluated For example, we want to increase by (the jump ) after a presynaptic spike:

17 # create synapse S = Synapses(LIF, pre='g_syn += g_jump') S.connect(0,1) Here, the Synapses function only defines the synapse model We use S.connect(0,1) to connect neurons 0 (pre) and 1 (post) If you are getting an error message, you might have to change pre to on_pre You might also have to change S.connect(0,1) to S.connect(i=0, j=1) Brian2 changed this very recently

18 5. RECORD VARIABLES AND RUN We do the same as before, but ask to record more variables this time: # indicate what to record rec = StateMonitor(LIF, ('I','u', 'I_syn', 'g_syn'), record=true) # run the simulation for 200 ms run(200*ms)

19 6. PLOT Let s first plot the input current that we set manually: # plot the manual input current plot(rec.t*1000, rec.i[0]*10**12) plt.xlabel('time (ms)') plt.ylabel('i (pa)') Here we multiply I (in A) by to get pa We see that there is input of 200pA between t=51 and t=65 We can check the input for the postsynaptic neuron by plotting rec.i[1] instead It should be just a line at zero

20 Now create a new cell and plot # plot the synaptic conductivity plot(rec.t*1000, rec.g_syn[1]*10**9) plt.xlabel('time (ms)') plt.ylabel('membrane conductivity (ns)') Here we multiply (in Siemens) by to get nano Siemens (ns) We can check the conductivity for the presynaptic neuron by plotting rec.g_syn[0] instead Again, it should be just a line at zero

21 Now create a new cell and plot # plot the PSC plot(rec.t*1000, rec.i_syn[1]*10**12) plt.xlabel('time (ms)') plt.ylabel('postsynaptic current (pa)') Here we multiply (in A) by to get pa We can check for the presynaptic neuron by plotting rec.i_syn[0] instead Again, it should be just a line at zero

22 Finally, create a new cell and plot # plot the PSP plot(rec.t*1000, rec.u[0]*1000) plt.xlabel('time (ms)') plt.ylabel('membrane potential (mv)') Here we multiply (in V) by to get mv We started by plotting the presynaptic neuron (index 0), to check how many times it spiked Now plot the postsypantic neuron by using rec.u[1] You should see a typical EPSP

23 7. CHANGING THE MODEL PARAMETERS What do you think that will happen to the EPSP if you increase? Try setting tau_decay = 4 * ms Now try tau_decay = 10 * ms WTF? Slower decay of means that the current stays strong longer More input to be integrated by the LIF!! Why does the EPSC change abruptly during the spike? Because of the changes in due to the spike and reset!

24 This is a model of an excitatory synapse, perhaps mediated by AMPA channels How can we make this a model of an inhibitory synapse, mediated by GABA? We only have to make one important change: Set E_syn = -70 We can also change tau_decay = 6 * ms, because GABA has slower unbinding, and re-run Gerstner recommends using two exponentials for GABA channels, but we will stick with a single equation; the opening of channels is very fast, so this is an OK approximation

25 8. TEMPORAL INTEGRATION Now let s look at temporal integration of EPSPs Set E_syn = 0 and tau_decay = 2 * ms Change the manual input to the presynaptic neuron to 400 pa from t=51 to t=100 Re-run the simulation Create a new plot with the pre-synaptic membrane potential, to check spikes Check the plots of all variables for the post-synaptic membrane potential

26 THAT S IT!

PROGRAMMING TUTORIAL 2: SIMULATING A LIF NEURON IN BRIAN2

PROGRAMMING TUTORIAL 2: SIMULATING A LIF NEURON IN BRIAN2 FABIAN SOTO SEPTEMBER 7, 2016 GETTING STARTED Open a jupyter notebook Import brian2 and other tools that you will use You should get used to include