5. Type I and type II neuron models¶
Book chapters
See Chapter 4 and especially Chapter 4 Section 4 for background knowledge on Type I and Type II neuron models.
Python classes
The neurodynex.neuron_type.typeXY
module contains all classes required for this exercise.
For the exercises you will need to import the classes NeuronX
and NeuronY
by running
from neurodynex.neuron_type.typeXY import NeuronX, NeuronY
Note
Both NeuronX
and NeuronY
inherit from a common base class neuron_type.neurons.NeuronAbstract
and thus implement similar methods.
For those who are interested, here is more about classes and inheritance in Python.
5.1. Exercise: Probing Type I and Type II neuron models¶
This exercise deals not only with Python functions, but with python objects.
The classes NeuronX
and NeuronY
both are neurons, that have different dynamics: one is Type I and one is Type II. Finding out which class implements which dynamics is the goal of the exercise.
To run the exercises you will have to instantiate these classes. You can then plot step_current injections (using the step
method) or extract the firing rate for a given step current (using the get_rate
method):
from neurodynex.neuron_type.typeXY import NeuronX, NeuronY
n1 = NeuronX() # instantiates a new neuron of type X
n1.step(do_plot=True) # plot a step current injection
To check your results, you can use the get_neuron_type
function, e.g.:
>> n1 = NeuronX() # instantiates a new neuron of type X
>> n1.get_neuron_type()
neurodynex.neuron_type.neurons.NeuronTypeOne
5.1.1. Question: Estimating the threshold¶
What is the threshold current for repetitive firing for NeuronX
and NeuronY
?
Exploring various values of I_amp
, find the range in which the
threshold occurs, to a precision of 0.01.
Note
As shown abve, use the step
functions to plot the responses to step current which starts after 100ms (to let the system equilibrate) and lasting at least 1000ms (to detect repetitive firing with a long period):
Already from the voltage response near threshold you might have an idea which is type I or II, but let’s investigate further.
5.1.2. Question: Pulse response¶
Plot the response to short current pulses near threshold, and interpret the results: which class is Type I, which is II?
For example:
import matplotlib.pyplot as plt
plt.figure() # new figure
n1 = NeuronX() # instantiates a new neuron of type X
t, v, w, I = n1.step(I_amp=1.05, I_tstart=100, I_tend=110, t_end=300)
plt.plot(t,v)
t, v, w, I = n1.step(I_amp=1.1, I_tstart=100, I_tend=110, t_end=300)
plt.plot(t,v)
# can you simplify this in a loop?
plt.show()
5.2. Exercise: f-I curves¶
During the questions of this exercise you will write a python script that plots the f-I curve for type I and type II neuron models.
5.2.1. Get firing rates from simulations¶
We provide you with a function get_spiketimes
to determine the spike times from
given timeseries t
and v
:
>> from neurodynex.neuron_type.neurons import get_spiketimes
>> t, v, w, I = n1.step(I_amp=1.0, I_tstart=100, I_tend=1000., t_end=1000.)
>> st = get_spiketimes(t, v)
>> print st
[ 102.9 146.1 189.1 ... ]
Use this function to write a Python function (in your own .py file) that calculates an estimate of the firing rate, given a neuron instance and an input current:
def get_firing_rate(neuron, I_amp):
# run a step on the neuron via neuron.step()
# get the spike times
# calculate the firing rate f
return f
Note
To calculate the firing rate, first calculate the inter-spike intervals (time difference between spikes) from the spike times using this elegant indexing idiom
isi = st[1:]-st[:-1]
Then find the mean and take the reciprocal (pay attention when converting from 1/ms to Hz) to yield the firing-rate:
f = 1000.0/mean(isi)
Note
You can check your results by calling:
# get firing rate and plot the dynamics for an injection of I_amp
n1.get_rate(I_amp, do_plot=True)
5.2.2. Plot the f-I curve¶
Now let’s use your function get_firing_rate
to plot an f-vs-I curve for both neuron classes.
Add the following function skeleton to your code and complete it to plot the f-I curve, given the neuron class as an argument:
import matplotlib.pyplot as plt
import numpy as np
def plot_fI_curve(NeuronClass):
plt.figure() # new figure
neuron = NeuronClass() # instantiate the neuron class
I = np.arange(0.0,1.05,0.1) # a range of current inputs
f = []
# loop over current values
for I_amp in I:
firing_rate = # insert here a call to your function get_firing_rate( ... )
f.append(firing_rate)
plt.plot(I, f)
plt.xlabel('Amplitude of Injecting step current (pA)')
plt.ylabel('Firing rate (Hz)')
plt.grid()
plt.show()
- Call your
plot_fI_curve
function with each classNeuronX
andNeuronY
as argument. - Change the
I
range to zoom in near the threshold, and try running it again for both classes.
Which class is Type I and which is Type II?