LGBIO2072_TP1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/fblondiaux/LGBIO2072-2020/blob/update/LGBIO2072_TP1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3dfPteL6r_fC"
   },
   "source": [
    "# Leaky Integrate and Fire (LIF) Tutorial\n",
    "__Authors:__ Antoine de Comite and Flo Blondiaux\n",
    "\n",
    "__Content inspired from__: Neuromatch Academy github.com/NeuromatchAcademy\n",
    "\n",
    "Please run the cells below to initialize the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4bYIj4tBr_fL"
   },
   "outputs": [],
   "source": [
    "#Useful libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pJwr1fQ8r_fa"
   },
   "outputs": [],
   "source": [
    "# @title Figure Settings\n",
    "import ipywidgets as widgets  # interactive display\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "# use NMA plot style\n",
    "plt.style.use(\"https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/nma.mplstyle\")\n",
    "my_layout = widgets.Layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YdjGjCOIr_fF"
   },
   "source": [
    "---\n",
    "## Tutorial Objectives\n",
    " In this tutorial, we will build up a leaky integrate-and-fire (LIF) neuron model and study its dynamics in response to various types of inputs. In particular, we are going to write a few lines of code to:  \n",
    "\n",
    "- simulate the LIF neuron model\n",
    "\n",
    "- drive the LIF neuron with external inputs, such as direct currents, Gaussian white noise, sinusoidal currents, ...\n",
    "- study how different inputs affect the  LIF neuron's output (firing rate and spike time irregularity)\n",
    "\n",
    "Here, we will especially emphasize identifying conditions (input statistics) under which a neuron can spike at low firing rates and in an irregular manner. The reason for focusing on this is that in most cases, neocortical neurons spike in an irregular manner.\n",
    "\n",
    "\n",
    "---\n",
    " <font color='red'> If you are working in google colab, in order to save your work, go to File > \"Save a copy in Drive\" and work on the copy. If you don't do this, you will loose all your modifications when you close the tab ! </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hX_rGdJsr_fH"
   },
   "source": [
    "---\n",
    "## Reminder\n",
    "\n",
    "A *membrane equation* and a *reset condition* define our *leaky-integrate-and-fire (LIF)* neuron:\n",
    "\n",
    "\n",
    "\\begin{equation*}\n",
    "\\tau_m \\frac{du}{dt} = -\\left(u(t)-u_{rest}\\right) +RI(t)  \\;\\;\\; if \\; u(t)\\leq \\theta\n",
    "\\end{equation*}\n",
    "\n",
    "\\begin{equation*}\n",
    "u(t) = u_{reset}  \\;\\;\\;\\;\\;\\;\\;\\;\\;  otherwise\n",
    "\\end{equation*}\n",
    "\n",
    "\n",
    "The membrane equation is an *ordinary differential equation (ODE)* that describes the time evolution of membrane potential $u(t)$ in response to synaptic input and leaking of change across the cell membrane. To find an approximation of the solution of this ODE, you can use explicit Euler integration over one time step.\n",
    "Euler integration :\n",
    "\\begin{equation*}\n",
    "\\frac{dX(t)}{dt} \\simeq \\frac{X(t+\\Delta t) - X(t)}{\\Delta t}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yzgkkTUcr_fn"
   },
   "source": [
    "## Synaptic input\n",
    "\n",
    "We start with a sinusoidal model to simulate the synaptic input $I(t)$ given by:\n",
    "\\begin{align*}\n",
    "\\\\\n",
    "I(t)=I_{mean}\\left(1+\\sin\\left(\\frac{2 \\pi}{0.01}\\,t\\right)\\right)\\\\\n",
    "\\\\\n",
    "\\end{align*}\n",
    "\n",
    "### Exercice 1\n",
    "Compute the values of synaptic input $I(t)$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2Rwr4Q9Ar_fp"
   },
   "outputs": [],
   "source": [
    "def syn_in(t, imean = 25e-11):\n",
    "    \"\"\"\n",
    "    Function that produces sinusoidal input\n",
    "\n",
    "    Args:\n",
    "      t          : Vector of discretized time points (numpy array)\n",
    "      imean      : current mean amplitude [A] (integer)\n",
    "\n",
    "    Returns:\n",
    "      sin_i       : Sinusoidal input current (numpy array)\n",
    "    \"\"\"\n",
    "    ########################\n",
    "    #### Your code here ####\n",
    "    ########################\n",
    "    return sin_i\n",
    "\n",
    "t_max = 150e-3   # second\n",
    "dt = .1e-3        # second\n",
    "t_range = ... #Fill here\n",
    "\n",
    "#Plot here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Example output:*\n",
    "\n",
    "<img alt='Solution hint' align='left' width=413 height=300 src=https://raw.githubusercontent.com/fblondiaux/LGBIO2072-2020/master/Images/TP1-Ex1.png>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VnQi9EGyr_fz"
   },
   "source": [
    "---\n",
    "## ODE integration without spikes\n",
    "In the next exercise, we now simulate the evolution of the membrane equation in discrete time steps, with a sufficiently small $\\Delta t$.\n",
    "\n",
    "**Start by writing an approximation for the time derivative $\\dfrac{d}{dt}\\,u(t)$ in discrete time** using discrete-time integration methods such as Euler method. See [Numerical methods for ordinary differential equations](https://en.wikipedia.org/wiki/Numerical_methods_for_ordinary_differential_equations) for additional details.\n",
    "\n",
    "### Exercice 2 \n",
    "Implement the evolution of the membrane potential in response to an input_current. Use the synusoidal input you just coded but try also with a step current as an input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wPLB624zr_f0"
   },
   "outputs": [],
   "source": [
    "def membranePot(input_current, t, tau= 20e-3 , urest= -60e-3 , r= 100e6):\n",
    "    \"\"\"\n",
    "    Authors : Antoine de Comite and Flo Blondiaux\n",
    "    Simulate the integration of the membrane potential with external input current\n",
    "\n",
    "    Args:\n",
    "      input_current   : Vector containing the input current [A].\n",
    "      t               : Vector containing the discretized time points [s].\n",
    "      tau             : Membrane time constant. Default value: 20e-3 [s]\n",
    "      urest           : Leak potential. Default value: -60e-3 [V]\n",
    "      r               : Leak resistance. Default value: 100e6 [Ohm]\n",
    "    Returns:\n",
    "      u               : membrane potential [V]\n",
    "    \"\"\"\n",
    "    ########################\n",
    "    #### Your code here ####\n",
    "    ########################\n",
    "    return u\n",
    "\n",
    "#Plot your results here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OKgevsxjpp4f"
   },
   "source": [
    "*Example output:*\n",
    "\n",
    "\n",
    "<img alt='Solution hint' align='left' width=413 height=300 src=https://raw.githubusercontent.com/fblondiaux/LGBIO2072-2020/master/Images/TP1-Ex2.png>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dQ1GNvF-r_f_"
   },
   "source": [
    "---\n",
    "# Introduce spikes\n",
    "A spike takes place whenever $u(t)$ crosses $\\theta$. In that case, a spike is recorded and $u(t)$ resets to $u_{reset}$ value. This is summarized in the *reset condition*:\n",
    "$$u(t) = u_{reset}\\quad \\text{ if } u(t)\\geq \\theta$$\n",
    "\n",
    "For more information about spikes or action potentials see [here](https://en.wikipedia.org/wiki/Action_potential).\n",
    "\n",
    "\n",
    "![spikes cartoon](https://raw.githubusercontent.com/fblondiaux/LGBIO2072-2020/master/Solutions/spikes_carton.png)\n",
    "\n",
    "### Exercice 3 \n",
    "Add the spiking process to your LIF model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AWXY5ag2r_gA"
   },
   "outputs": [],
   "source": [
    "def simple_LIF(input_current,t,  tau= 20e-3 , urest= -60e-3 , r= 100e6, ureset = -70e-3 \\\n",
    "               ,theta = -50e-3 ):\n",
    "    \"\"\"\n",
    "    Authors : Antoine de Comite and Flo Blondiaux\n",
    "    Simulate the integration of the membrane potential and the generation of spikes\n",
    "    in response to an external input current\n",
    "\n",
    "    Args:\n",
    "      input_current   : Vector containing the input current [A].\n",
    "      t               : Vector containing the discretized time points [s]\n",
    "      tau             : Membrane time constant. Default value: 20e-3 [s]\n",
    "      urest           : Leak potential. Default value: -60e-3 [V]\n",
    "      r               : Leak resistance. Default value: 100e6 [Ohm]\n",
    "      ureset          : Reset potential. Default value: -70e-3[V]\n",
    "      theta           : Firing threashold. Default value: -50e-3 [V]\n",
    "    Returns:\n",
    "      u               : membrane potential [V]\n",
    "      ts              : spike times [s]\n",
    "    \"\"\"\n",
    "    ########################\n",
    "    #### Your code here ####\n",
    "    ########################\n",
    "    return u, ts\n",
    "\n",
    "t_max = 150e-3   # second\n",
    "dt = .1e-3       # second\n",
    "t_range = np.arange(0,t_max,dt)\n",
    "input_current = syn_in(t_range)\n",
    "u ,ts = simple_LIF(input_current, t_range)\n",
    "\n",
    "#plot your results here (use a subplot with the top panel representing the input current and bottom panel representing the membrane potential as well as the spikes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IiRFUsBH3Wf3"
   },
   "source": [
    "*Example output:*\n",
    "\n",
    "\n",
    "<img alt='Solution hint' align='left' width=413 height=300 src=https://raw.githubusercontent.com/fblondiaux/LGBIO2072-2020/master/Images/TP1-Ex3.png>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "idDCAOtmr_gJ"
   },
   "source": [
    "---\n",
    "# Refractory period\n",
    "\n",
    "The absolute refractory period is a time interval in the order of a few milliseconds during which synaptic input will not lead to a 2nd spike, no matter how strong. This effect is due to the biophysics of the neuron membrane channels, and you can read more about absolute and relative refractory period [here](https://content.byui.edu/file/a236934c-3c60-4fe9-90aa-d343b3e3a640/1/module5/readings/refractory_periods.html) and [here](https://en.wikipedia.org/wiki/Refractory_period_(physiology)).\n",
    "\n",
    "![refractory period plot](https://github.com/mpbrigham/colaboratory-figures/raw/master/nma/python-for-nma/refractory_period.png)\n",
    "\n",
    "### Exercise 4 \n",
    "Add the refractory period to your model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "njc8BtKIr_gK"
   },
   "outputs": [],
   "source": [
    "\n",
    "def LIF(input_current,t,  tau= 20e-3 , urest= -60e-3 , r= 100e6, ureset = -70e-3 \\\n",
    "               ,theta = -50e-3, t_ref = 10e-3 ): \n",
    "    \"\"\"\n",
    "    Authors : Antoine de Comite and Flo Blondiaux\n",
    "    Simulate the LIF model in response to an external input current\n",
    "\n",
    "    Args:\n",
    "      input_current   : Vector containing the input current [A].\n",
    "      t               : Vector containing the discretized time points [s]\n",
    "      tau             : Membrane time constant. Default value: 20e-3 [s]\n",
    "      urest           : Leak potential. Default value: -60e-3 [V]\n",
    "      r               : Leak resistance. Default value: 100e6 [Ohm]\n",
    "      ureset          : Reset potential. Default value: -70e-3[V]\n",
    "      theta           : Firing threashold. Default value: -50e-3 [V]\n",
    "      t_ref           : Refractory period. Default value: 10e-3 [S]\n",
    "    Returns:\n",
    "      u               : membrane potential [V]\n",
    "      ts              : spike times [s]\n",
    "    \"\"\"\n",
    "    ########################\n",
    "    #### Your code here ####\n",
    "    ########################\n",
    "    return u, ts\n",
    "\n",
    "t_max = 150e-3   # second\n",
    "dt = .1e-3        # second\n",
    "t_range = np.arange(0,t_max,dt)\n",
    "input_current = syn_in(t_range)\n",
    "u,ts = LIF(input_current, t_range)\n",
    "\n",
    "#plot here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nQ8Mv5MW41T1"
   },
   "source": [
    "*Example output:*\n",
    "\n",
    "\n",
    "<img alt='Solution hint' align='left' width=413 height=300 src=https://raw.githubusercontent.com/fblondiaux/LGBIO2072-2020/master/Images/TP1-Ex4.png>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6Mjkfp26r_gQ"
   },
   "source": [
    "### Exercice 5\n",
    "Explore different values for LIF parameters. *tref* is expressed in [ms], *R* in [MOhm], *tau_m* in [ms] and *theta_th* in [mV]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OHRlgNCZr_gR"
   },
   "outputs": [],
   "source": [
    "my_layout.width = '450px'\n",
    "@widgets.interact(\n",
    "    tref=widgets.FloatSlider(10, min=0, max=30, step=2, layout=my_layout),\n",
    "    R=widgets.FloatSlider(100, min=10, max=200, step=10, layout=my_layout),\n",
    "    tau_m = widgets.FloatSlider(20, min=5, max=40, step=2.5, layout=my_layout),\n",
    "    theta_th = widgets.FloatSlider(-50, min=-55, max=-45, step=1, layout=my_layout)\n",
    ")\n",
    "\n",
    "def diff_tref(tref = 10e-3, R = 100, tau_m= 20, theta_th = -50):\n",
    "    \n",
    "    t_max = 150e-3   # second\n",
    "    dt = .1e-3        # second\n",
    "    t_range = np.arange(0,t_max,dt)\n",
    "    input_current = syn_in(t_range)\n",
    "    u,ts = LIF(input_current, t_range,t_ref = tref*1e-3, r=R*1e6, tau = tau_m *1e-3,theta = theta_th*1e-3 )\n",
    "\n",
    "    fig, axs = plt.subplots(2)\n",
    "    axs[0].plot(t_range,input_current)\n",
    "    axs[0].set(title = \"Input current\", ylabel = \"I [A]\")\n",
    "    axs[1].plot(t_range,u)\n",
    "    axs[1].plot(ts,np.ones(len(ts))*-40e-3,'r.',markersize=12)\n",
    "    axs[1].set(title = \"Membrane potential\", ylabel = \"u [V]\", xlabel= \"Time [S]\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 6\n",
    "\n",
    "Investigate the relationship between the input current and the number of spikes generated by the LIF neuron model within a defined time window. Plot input direct current (X-axis) against the corresponding spike count (Y-axis). Is the relationship between input current and spike count linear ? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Qs7OSZDdr_gX"
   },
   "source": [
    "---\n",
    "## Random synaptic input\n",
    "From the perspective of neurons, synaptic input is random (or stochastic). We'll improve the synaptic input model by introducing random input current with statistical properties similar to the previous exercise:\n",
    "\n",
    "\\begin{align*}\n",
    "\\\\\n",
    "I(t)=I_{mean}\\left(1+0.1\\sqrt{\\frac{t_{max}}{\\Delta t}}\\,\\xi(t)\\right)\\qquad\\text{with }\\xi(t)\\sim \\mathcal{N}(0,\\sigma)\\\\\n",
    "\\\\\n",
    "\\end{align*}\n",
    "\n",
    "where $\\mathcal{N}(0,\\sigma)$ is the [gaussian distribution](https://en.wikipedia.org/wiki/Normal_distribution).\n",
    "\n",
    "Random synaptic input $I(t)$ results in random time course for $u(t)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DugJys0Rr_gY"
   },
   "source": [
    "### Exercise 7\n",
    "Implement a function that generates the input current given above\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5ELv8qv8r_ga"
   },
   "outputs": [],
   "source": [
    "def rand_syn(t,sigma = 0.1, imean = 25e-11):\n",
    "    \"\"\"\n",
    "    Function that produces random input current\n",
    "\n",
    "    Args:\n",
    "      t          : vector of discretized time points \n",
    "      imean      : current mean amplitude [A]\n",
    "      sigma      : variance of the random input current\n",
    "\n",
    "    Returns:\n",
    "      sin_i       : Sinusoidal input current\n",
    "    \"\"\"\n",
    "    ########################\n",
    "    #### Your code here ####\n",
    "    ########################\n",
    "    return rand_i\n",
    "\n",
    "#Plot your results\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HzKwM4Qa9dTu"
   },
   "source": [
    "*Example output:*\n",
    "\n",
    "\n",
    "<img alt='Solution hint' align='left' width=413 height=300 src=https://raw.githubusercontent.com/fblondiaux/LGBIO2072-2020/master/Images/TP1-Ex6.png>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FR3ChJGhr_gg"
   },
   "source": [
    "Once you have implemented the random input current, explore the effect different values of sigma have on the membrane potential"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-0U8W2Mtr_gh"
   },
   "outputs": [],
   "source": [
    "# @title\n",
    "# @markdown Make sure you execute this cell to enable the widget!\n",
    "my_layout.width = '450px'\n",
    "@widgets.interact(\n",
    "    sigma=widgets.FloatSlider(0.8, min=0, max=5, step=0.2, layout=my_layout)\n",
    "\n",
    ")\n",
    "\n",
    "def diff_DC(sigma = 0.1):\n",
    "    t_max = 150e-3   # second\n",
    "    dt = 1e-3        # second\n",
    "    t_range = np.arange(0,t_max,dt)\n",
    "    input_current = rand_syn(t_range, sigma)\n",
    "    u,ts = LIF(input_current, t_range)\n",
    "    \n",
    "    fig, axs = plt.subplots(2)\n",
    "    axs[0].plot(t_range,input_current)\n",
    "    axs[0].set(title = \"Input current\", ylabel = \"I [A]\")\n",
    "    axs[1].plot(t_range,u)\n",
    "    axs[1].plot(ts,np.ones(len(ts))*-40e-3,'r.',markersize=12)\n",
    "    axs[1].set(title = \"Membrane potential\", ylabel = \"u [V]\", xlabel= \"Time [S]\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Non-linear model of spiking\n",
    "The cell below implements the model of Izhikevich. It is a non-linear model of spiking activity which reproduces several patterns that cannot be reproduced in the context of linear Leak-Integrate-and-Fire model including rich spiking and bursting dynamics exhibited by cortical\n",
    "neurons.\n",
    "\n",
    "The model is defined by two differential equations of the form\n",
    "\\begin{equation*}\n",
    "v' = 0.004v^2 + 5v + 140 - u + I \n",
    "\\end{equation*}\n",
    "\n",
    "\\begin{equation*}\n",
    "u' = a(bv-u)\n",
    "\\end{equation*}\n",
    "\n",
    "with the auxilary after-spike resetting\n",
    "\n",
    "\\begin{equation*}\n",
    "\\text{if } v \\geq 30mV, \\text{then } v=c \\text{ , }u=u+d\n",
    "\\end{equation*}\n",
    "\n",
    "With $u(t)$ a membrane recovery variable which provides negative feedback to the membrane potential $v(t)$. $u(t)$ accounts for the activation of the $K^+$ ionic currents and the inactivation of $Na^+$ ionic currents. $v$ has mV scale.\n",
    "\n",
    "The parameters a,b,c and d must be modified to produce specific patterns of activity. Details can be found here: https://www.izhikevich.org/publications/spikes.pdf\n",
    "\n",
    "### Exercise 8\n",
    "\n",
    "Using this information, implement the non-linear model of spiking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def izhikevich(input_current,t, a = 0.02, b= 0.2, c = -50, d = 2, thresh = 30 ): \n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    Authors : Flo Blondiaux\n",
    "\n",
    "    Simulate the Izhikevich model in response to an external input current\n",
    "\n",
    "    Args:\n",
    "\n",
    "      input_current   : Vector containing the input current [A].\n",
    "      t               : Time vector expressed in [ms]\n",
    "        \n",
    "    Returns:\n",
    "      u               : membrane potential [V]\n",
    "      ts              : spike times [s]\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    ########################\n",
    "\n",
    "    #### Your code here ####\n",
    "\n",
    "    ########################\n",
    "    return v,u\n",
    "\n",
    "t_max = 200000e-3   # second\n",
    "dt = .1e-3       # second\n",
    "t_range = np.arange(0,t_max,dt)\n",
    "input_current = np.ones_like(t_range)*10\n",
    "input_current[0:500000] = 0\n",
    "v,u = izhikevich(input_current, t_range)\n",
    "#plot here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Example output:*\n",
    "\n",
    "\n",
    "<img alt='Solution hint' align='left' width=413 height=300 src=https://raw.githubusercontent.com/fblondiaux/LGBIO2072-2020/master/Images/TP1-Ex8.png>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore the influence of the different parameters using the following widget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_layout.width = '450px'\n",
    "@widgets.interact(\n",
    "    a=widgets.FloatSlider(0.02, min=0.01, max=.15, step=.01, layout=my_layout),\n",
    "    b=widgets.FloatSlider(0.2, min=.10, max=.35, step=.01, layout=my_layout),\n",
    "    c = widgets.FloatSlider(-50, min=-75, max=-40, step=2, layout=my_layout),\n",
    "    d = widgets.FloatSlider(2, min=0.05, max=10, step=0.05, layout=my_layout)\n",
    ")\n",
    "\n",
    "def test_params(a =0.02, b= 0.2, c=-50, d=2):\n",
    "    \n",
    "    t_max = 200000e-3   # second\n",
    "    dt = .1e-3       # second\n",
    "    t_range = np.arange(0,t_max,dt)\n",
    "    input_current = np.ones_like(t_range)*10\n",
    "    input_current[0:500000] = 0\n",
    "    v,u = izhikevich(input_current, t_range,a,b,c,d)\n",
    "\n",
    "    fig, axs = plt.subplots(2)\n",
    "    axs[0].plot(t_range,v)\n",
    "    axs[0].set(title = \"Membrane potential\", ylabel = \"u [mV]\")\n",
    "    axs[1].plot(t_range,u)\n",
    "    axs[1].plot(t_range,u)\n",
    "    axs[1].set(title = \"Membrane recovery variable\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 9\n",
    "\n",
    "Implement two types of neurons from the following list: Regular spiking (RS), Intrinsically bursting (IB), fast spiking (FS), thalamo-cortical (TC); resonator (RZ), low-threshold spiking (LTS). The example was a chattering neuron. More information can be obtained here: Details can be found here: https://www.izhikevich.org/publications/spikes.pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Implement the two kind of neurons here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C9tfhj4Ir_hP"
   },
   "source": [
    "---\n",
    "## Bonus Section 1: Orenstein-Uhlenbeck Process\n",
    "\n",
    "When a neuron receives spiking input, the synaptic current is Shot Noise – which is a kind of colored noise and the spectrum of the noise determined by the synaptic kernel time constant. That is, a neuron is driven by colored noise and not GWN.\n",
    "\n",
    "We can model colored noise using the Ornstein-Uhlenbeck process - filtered white noise.\n",
    "\n",
    "-> code this exercise [here](https://compneuro.neuromatch.io/tutorials/W2D3_BiologicalNeuronModels/student/W2D3_Tutorial1.html?highlight=leak%20integrate%20fire#bonus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Bonus Section 2: Generalized Integrate-and-Fire models\n",
    "\n",
    "LIF model is not the only abstraction of real neurons. If you want to learn about more realistic types of neuronal models, watch a Bonus Video!\n",
    "\n",
    "Click [here](https://compneuro.neuromatch.io/tutorials/W2D3_BiologicalNeuronModels/student/W2D3_Tutorial1.html?highlight=leak%20integrate%20fire#bonus-section-2-generalized-integrate-and-fire-models) for the video."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "LGBIO2072_TP1.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}