# 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 class`NeuronX`

and`NeuronY`

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?