PROGRAMMING TUTORIAL 2: SIMULATING A LIF NEURON IN BRIAN2

Transcription

1 PROGRAMMING TUTORIAL 2: SIMULATING A LIF NEURON IN BRIAN2 FABIAN SOTO SEPTEMBER 7, 2016

2 GETTING STARTED Open a jupyter notebook Import brian2 and other tools that you will use You should get used to include the following lines of code in the first cell of all your simulations:

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. DEFINE THE MODEL PARAMETERS The equation for the LIF model is: τ du m dt u rest = [u(t) ] + RI(t) Besides this, when u(t) = ϑ, we reset to u r Create a new cell and define the model parameters:

5 # 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

6 CREATE AN INPUT CURRENT ARRAY In all our simulations, we will take steps of 1 ms To give input to the model, we can create an array with the value of that input during each milisecond For example, a single input of 200 Amps at t = 3 would look like this: [ ] To create such an array, we use Numpy Because we imported numpy as np, all its functions can be called by writing np.function_name

7 For example, there is a function called arange(a,b) that creates an array of values from a to b-1 You can create an array with numbers from 1 to 10 by running np.arange(1,11) You can assign that array to a variable: myarray = np.arange(1,11) The elements inside myarrayhave an index going from 0 to 9 Remember that the index starts at zero in python!!

8 You can get the value of an element by running myarray[i]with iequal to any number between 0 and 9 Try it with different values of i You can also get the value of several consecutive elements by using start:end+1 For example, if you want to get the values [1, 2, 3, 4, 5], you should run myarray[0:5]

9 You use the same notation to change the value of specific elements in your array For example, let s say that you want to change the fi h element to 400 You should run myarray[4] = 400and then call myarray

10 Going back to our task of creating an input current array, we can start by creating an array with only zeros The function np.zeros(n)creates an array of N zeros Let s say that we want to run the simulation for one second That s 1,000 ms, so we define input_current = np.zeros(1000)

11 Next, let s say that we want to include a current of 200 pico amperes that starts at 101 ms and ends at 500 ms We run input_current[100:500] = 200 Finally, we need to tell Brian2 that this is a timed array with pico amperes units We use the function TimedArray: input_current=timedarray(tmp*pamp,dt=1*ms)

12 To recapitulate, you should now have the following in a python cell: # creating an input current array # I = 200pA, between 101 ms and 500 ms input_current = np.zeros(1000) input_current[100:500] = 200 input_current = TimedArray(input_current*pamp, dt=1*ms)

13 3. WRITE THE MODEL S EQUATIONS Brian2 allows to write differential equations for any model The equations must be written in a string: '''equation here''' To keep clean code, we will store this string in a variable called eqs Each equation is stored in a different line At the end of the line, write : unitwhere unitis the unit of measurement for a variable (e.g., volt, amp) Assigning our input_currentarray to I requires its own line:

14 τ m du dt u rest = [u(t) ] + RI(t) # define equation for the LIF model eqs = ''' du/dt = ( -(u - u_rest) + R*I ) / tau : volt I = input_current(t) : amp '''

15 4. SET THRESHOLD AND RESET Using our equation and parameters, now we can create a LIF neuron model using the function NeuronGroup: LIF = NeuronGroup(1, eqs, threshold='u>thr', reset='u=u_r') The 1 here represents how many neurons we want to run The string 'u > thr'sets the threshold to thr The string 'u=u_r'sets the reset value to u_r We already set thrto -50 mv and u_rto -70 mv earlier

16 5. SET INITIAL VALUES We can set initial values for the variables in our differential equations For example, usually we will want to start the membrante potential at its resting value The initial values are stored in the LIFobject that we created earlier To set them, we write LIF.followed by the name of the variable For example, LIF.u = u_restwill set the potential to u rest

17 6. RECORDING NEURONAL VARIABLES Before we run the simulation, we need to tell Brian2 what to record To record membrane potential, we use the function StateMonitor For example: rec = StateMonitor(LIF, 'u', record=true) u(t) will be recorded as an array in rec.u[0] To record only spikes, we use the function SpikeMonitor For example: rec = SpikeMonitor(LIF) The number of spikes is stored in rec.count[0]

18 7. RUNNING THE SIMULATION To run the simulation we use the run()function: run(1*second) Run it first recording the membrane potential

19 8. PLOTTING RESULTS To plot the results, we use the matplotlib library If you want to learn more about the library, go to Here we will just use simple line plots through the function plt.plot(x,y), which require providing values for the x and y axes We want to plot time in the x-axis and u(t) in the y-axis The membrane potential is in volts, so we can convert to mv by multiplying by 1000:

20 plt.plot(rec.t/ms, rec.u[0]*1000) plt.xlabel('time (ms)') plt.ylabel('membrane potential (mv)')

21 Now that we have a full simulation, let s play around with the model First, reduce the value of the input to 100 pa Second, increase the value of the input to 150 pa Now, run the simulation with an impulse input at 50 ms, which lasts only for 1 ms and has amplitude of 500 pa

22 9. ADDING NOISE IN A SIMULATION Real neurons are noisy, so sometimes we might want to add random noise to the membrane potential In Brian2, we do this using the symbol xi, which represents a Gaussian random variable with mean 0 and standard deviation of 1 In general, we add the expression sigma*xi*tau**-0.5to our equation of the membrane potential sigmasimply scales the random variable, and tauis the membrane time constant

23 # define sigma sigma = 1*mvolt # define equation for the LIF model eqs = ''' du/dt = ( -(u - u_rest) + R*I ) / tau + sigma*xi*tau**-0.5 : volt I = input_current(t) : amp ''' Try running the simulation again with an input of 150 pa (didn t produce spikes before), but with this added noise Reduce the noise to σ = 0.1mV and run the simulation again

24 USING FOR LOOPS IN PYTHON Sometimes we will want to run the same simulation many times, with small changes For example, we might want to change the input current and store how many spikes we saw For this, we use forloops Let s say that we want to loop through several input values that are stored in an array inputs = [100, 200, 300, 400] For now, we just want to print the values We do the following:

25 inputs = np.array([100, 200, 300, 400]) for i in inputs: print i We can also store the value of some operation in a resultsarray We start by creating an empty array of size 4: results = np.zeros(4) Then we store our result in each iteration of the loop We will iterate across an array of indexes, crated through the function range

26 inputs = np.array([100, 200, 300, 400]) results = np.zeros(4) for i in range(4): results[i] = inputs[i]*9-400 print results

27 forloops will make your life easier in the homeworks Instead of repeating the same simulation many times and writing down the results, you can iterate over some array (e.g., an array of inputs) Each time, you use a different value from the input array in your simulation and store recorded values from the simulation into another array