{ "cells": [ { "cell_type": "markdown", "id": "header", "metadata": {}, "source": [ "# Hodgkin-Huxley Neuron Model\n", "\n", "This tutorial demonstrates how to implement biologically realistic neuron models using BrainState. The Hodgkin-Huxley (HH) model is one of the most important models in computational neuroscience, describing action potential generation in neurons through ion channel dynamics.\n", "\n", "## Learning Objectives\n", "\n", "By the end of this tutorial, you will:\n", "- Understand the Hodgkin-Huxley neuron model\n", "- Use BrainUnit for physical units and dimensional analysis\n", "- Implement biophysically detailed neuron dynamics\n", "- Simulate and visualize neuron spiking activity\n", "- Use BrainState's `Dynamics` class for continuous-time models\n", "\n", "## The Hodgkin-Huxley Model\n", "\n", "The HH model describes the electrical activity of neurons through:\n", "\n", "1. **Membrane Voltage** (`V`): The electrical potential across the cell membrane\n", "2. **Ion Channels**:\n", " - **Sodium (Na⁺)** channels with activation (`m`) and inactivation (`h`) gates\n", " - **Potassium (K⁺)** channels with activation (`n`) gates\n", " - **Leak** channels\n", "\n", "**Governing Equations**:\n", "```\n", "C dV/dt = -I_Na - I_K - I_leak + I_ext\n", "I_Na = gNa * m³ * h * (V - ENa)\n", "I_K = gK * n⁴ * (V - EK)\n", "I_leak = gL * (V - EL)\n", "```\n", "\n", "Each gate variable (m, h, n) follows:\n", "```\n", "dx/dt = α(V) * (1 - x) - β(V) * x\n", "```" ] }, { "cell_type": "markdown", "id": "setup", "metadata": {}, "source": [ "## Setup and Imports" ] }, { "cell_type": "code", "execution_count": 1, "id": "imports", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:09:30.939767Z", "start_time": "2025-10-11T10:09:26.977055Z" } }, "outputs": [], "source": [ "import brainunit as u\n", "import jax.numpy as jnp\n", "import matplotlib.pyplot as plt\n", "import brainpy\n", "import brainstate\n", "\n", "# Set random seed\n", "brainstate.random.seed(42)" ] }, { "cell_type": "markdown", "id": "model_section", "metadata": {}, "source": [ "## Implementing the HH Model\n", "\n", "We'll use BrainState's `nn.Dynamics` class for continuous-time dynamics and BrainUnit for physical units:" ] }, { "cell_type": "code", "execution_count": 2, "id": "hh_model", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:09:30.973882Z", "start_time": "2025-10-11T10:09:30.961839Z" } }, "outputs": [], "source": [ "class HH(brainstate.nn.Dynamics):\n", " \"\"\"Hodgkin-Huxley neuron model.\n", " \n", " A biophysically detailed model of action potential generation.\n", " \"\"\"\n", " \n", " def __init__(\n", " self,\n", " in_size,\n", " ENa=50. * u.mV, # Sodium reversal potential\n", " gNa=120. * u.mS / u.cm ** 2, # Sodium conductance\n", " EK=-77. * u.mV, # Potassium reversal potential \n", " gK=36. * u.mS / u.cm ** 2, # Potassium conductance\n", " EL=-54.387 * u.mV, # Leak reversal potential\n", " gL=0.03 * u.mS / u.cm ** 2, # Leak conductance\n", " V_th=20. * u.mV, # Spike threshold\n", " C=1.0 * u.uF / u.cm ** 2 # Membrane capacitance\n", " ):\n", " super().__init__(in_size)\n", " \n", " # Store parameters\n", " self.ENa = ENa\n", " self.EK = EK\n", " self.EL = EL\n", " self.gNa = gNa\n", " self.gK = gK\n", " self.gL = gL\n", " self.C = C\n", " self.V_th = V_th\n", " \n", " # Sodium channel activation (m)\n", " def m_alpha(self, V):\n", " return 1. / u.math.exprel(-(V / u.mV + 40) / 10)\n", " \n", " def m_beta(self, V):\n", " return 4.0 * jnp.exp(-(V / u.mV + 65) / 18)\n", " \n", " def m_inf(self, V):\n", " return self.m_alpha(V) / (self.m_alpha(V) + self.m_beta(V))\n", " \n", " def dm(self, m, t, V):\n", " return (self.m_alpha(V) * (1 - m) - self.m_beta(V) * m) / u.ms\n", " \n", " # Sodium channel inactivation (h)\n", " def h_alpha(self, V):\n", " return 0.07 * jnp.exp(-(V / u.mV + 65) / 20.)\n", " \n", " def h_beta(self, V):\n", " return 1 / (1 + jnp.exp(-(V / u.mV + 35) / 10))\n", " \n", " def h_inf(self, V):\n", " return self.h_alpha(V) / (self.h_alpha(V) + self.h_beta(V))\n", " \n", " def dh(self, h, t, V):\n", " return (self.h_alpha(V) * (1 - h) - self.h_beta(V) * h) / u.ms\n", " \n", " # Potassium channel activation (n)\n", " def n_alpha(self, V):\n", " return 0.1 / u.math.exprel(-(V / u.mV + 55) / 10)\n", " \n", " def n_beta(self, V):\n", " return 0.125 * jnp.exp(-(V / u.mV + 65) / 80)\n", " \n", " def n_inf(self, V):\n", " return self.n_alpha(V) / (self.n_alpha(V) + self.n_beta(V))\n", " \n", " def dn(self, n, t, V):\n", " return (self.n_alpha(V) * (1 - n) - self.n_beta(V) * n) / u.ms\n", " \n", " def init_state(self, batch_size=None):\n", " \"\"\"Initialize state variables at rest.\"\"\"\n", " self.V = brainstate.HiddenState(\n", " jnp.ones(self.varshape, brainstate.environ.dftype()) * -65. * u.mV\n", " )\n", " self.m = brainstate.HiddenState(self.m_inf(self.V.value))\n", " self.h = brainstate.HiddenState(self.h_inf(self.V.value))\n", " self.n = brainstate.HiddenState(self.n_inf(self.V.value))\n", " \n", " def dV(self, V, t, m, h, n, I):\n", " \"\"\"Membrane voltage dynamics.\"\"\"\n", " # Sodium current\n", " I_Na = (self.gNa * m * m * m * h) * (V - self.ENa)\n", " \n", " # Potassium current\n", " n2 = n * n\n", " I_K = (self.gK * n2 * n2) * (V - self.EK)\n", " \n", " # Leak current\n", " I_leak = self.gL * (V - self.EL)\n", " \n", " # Total current\n", " dVdt = (- I_Na - I_K - I_leak + I) / self.C\n", " return dVdt\n", " \n", " def update(self, x=0. * u.mA / u.cm ** 2):\n", " \"\"\"\n", " Update neuron state for one time step.\n", " \n", " Args:\n", " x: Input current density\n", " \n", " Returns:\n", " spike: Boolean spike indicator\n", " \"\"\"\n", " t = brainstate.environ.get('t')\n", " \n", " # Update voltage and gating variables using exponential Euler\n", " V = brainstate.nn.exp_euler_step(\n", " self.dV, self.V.value, t, \n", " self.m.value, self.h.value, self.n.value, x\n", " )\n", " m = brainstate.nn.exp_euler_step(self.dm, self.m.value, t, self.V.value)\n", " h = brainstate.nn.exp_euler_step(self.dh, self.h.value, t, self.V.value)\n", " n = brainstate.nn.exp_euler_step(self.dn, self.n.value, t, self.V.value)\n", " \n", " # Detect spike (threshold crossing)\n", " spike = jnp.logical_and(self.V.value < self.V_th, V >= self.V_th)\n", " \n", " # Update states\n", " self.V.value = V\n", " self.m.value = m\n", " self.h.value = h\n", " self.n.value = n\n", " \n", " return spike" ] }, { "cell_type": "markdown", "id": "simulation_section", "metadata": {}, "source": [ "## Simulating the HH Neuron\n", "\n", "### Create and Initialize Neuron" ] }, { "cell_type": "code", "execution_count": 3, "id": "create_neuron", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:09:31.405628Z", "start_time": "2025-10-11T10:09:30.984238Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Created (10,) HH neurons\n", "Initial membrane potential: -65.0 * mvolt\n" ] } ], "source": [ "# Create a population of 10 HH neurons\n", "hh = HH(10)\n", "\n", "# Initialize states\n", "brainstate.nn.init_all_states(hh)\n", "\n", "# Set simulation parameters\n", "dt = 0.01 * u.ms\n", "brainstate.environ.set(dt=dt)\n", "\n", "print(f\"Created {hh.varshape} HH neurons\")\n", "print(f\"Initial membrane potential: {hh.V.value[0]}\")" ] }, { "cell_type": "markdown", "id": "run_section", "metadata": {}, "source": [ "### Define Simulation Function" ] }, { "cell_type": "code", "execution_count": 4, "id": "run_function", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:09:31.412660Z", "start_time": "2025-10-11T10:09:31.409641Z" } }, "outputs": [], "source": [ "def run(t, inp):\n", " \"\"\"Run neuron for one time step.\n", " \n", " Args:\n", " t: Current time\n", " inp: Input current\n", " \n", " Returns:\n", " V: Membrane voltage\n", " \"\"\"\n", " with brainstate.environ.context(t=t, dt=dt):\n", " hh(inp)\n", " return hh.V.value" ] }, { "cell_type": "markdown", "id": "simulate_section", "metadata": {}, "source": [ "### Run Simulation with Random Input" ] }, { "cell_type": "code", "execution_count": 5, "id": "simulate", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:09:31.835315Z", "start_time": "2025-10-11T10:09:31.433111Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running simulation for 100.0 * msecond...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bb130a2bcb70443a97e5b2ffbb8b3f7d", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/10000 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Convert to milliseconds and millivolts for plotting\n", "times_ms = times.to_decimal(u.ms)\n", "vs_mv = vs.to_decimal(u.mV)\n", "\n", "# Plot voltage traces for first 3 neurons\n", "fig, axes = plt.subplots(3, 1, figsize=(12, 8), sharex=True)\n", "\n", "for i in range(3):\n", " axes[i].plot(times_ms, vs_mv[:, i], linewidth=1.5)\n", " axes[i].set_ylabel(f'V{i} (mV)', fontsize=11)\n", " axes[i].grid(True, alpha=0.3)\n", " axes[i].axhline(y=20, color='r', linestyle='--', alpha=0.5, label='Threshold')\n", " if i == 0:\n", " axes[i].legend(fontsize=9)\n", "\n", "axes[2].set_xlabel('Time (ms)', fontsize=11)\n", "plt.suptitle('Hodgkin-Huxley Neuron Activity', fontsize=14, fontweight='bold')\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "analysis_section", "metadata": {}, "source": [ "### Analyze Spiking Statistics" ] }, { "cell_type": "code", "execution_count": 7, "id": "spike_stats", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:09:32.465674Z", "start_time": "2025-10-11T10:09:32.300998Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Spike counts per neuron:\n", " Neuron 0: 6 spikes\n", " Neuron 1: 6 spikes\n", " Neuron 2: 6 spikes\n", " Neuron 3: 6 spikes\n", " Neuron 4: 6 spikes\n", "\n", "Average firing rate: 60.00 Hz\n" ] } ], "source": [ "# Detect spikes (threshold crossings)\n", "import numpy as np\n", "\n", "threshold = 20.0 # mV\n", "spike_times = []\n", "spike_counts = []\n", "\n", "for i in range(hh.varshape[0]):\n", " # Find threshold crossings\n", " above_threshold = vs_mv[:, i] > threshold\n", " spike_indices = np.where(np.diff(above_threshold.astype(int)) > 0)[0]\n", " \n", " spike_times.append(times_ms[spike_indices])\n", " spike_counts.append(len(spike_indices))\n", "\n", "print(\"Spike counts per neuron:\")\n", "for i, count in enumerate(spike_counts[:5]):\n", " print(f\" Neuron {i}: {count} spikes\")\n", "\n", "print(f\"\\nAverage firing rate: {np.mean(spike_counts) / (duration.to_decimal(u.ms) / 1000):.2f} Hz\")" ] }, { "cell_type": "markdown", "id": "raster_section", "metadata": {}, "source": [ "### Raster Plot" ] }, { "cell_type": "code", "execution_count": 8, "id": "raster_plot", "metadata": { "ExecuteTime": { "end_time": "2025-10-11T10:09:32.621283Z", "start_time": "2025-10-11T10:09:32.480680Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(12, 6))\n", "\n", "for i, spikes in enumerate(spike_times[:10]):\n", " plt.scatter(spikes, [i] * len(spikes), marker='|', s=100, color='black')\n", "\n", "plt.xlabel('Time (ms)', fontsize=12)\n", "plt.ylabel('Neuron Index', fontsize=12)\n", "plt.title('Spike Raster Plot', fontsize=14, fontweight='bold')\n", "plt.ylim(-0.5, 9.5)\n", "plt.grid(True, alpha=0.3, axis='x')\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "next_steps", "metadata": {}, "source": [ "## Next Steps\n", "\n", "- **Network Models**: Build networks of neurons with synapses\n", "- **Learning Rules**: Implement STDP and other plasticity mechanisms\n", "- **Brain Regions**: Model cortical columns, hippocampus, etc.\n", "- **Spiking Networks**: Training spiking neural networks\n", "\n", "## References\n", "\n", "- [Hodgkin & Huxley (1952) Original Paper](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC1392413/)\n", "- [Neuronal Dynamics Book](https://neuronaldynamics.epfl.ch/)\n", "- [BrainState Documentation](https://brainstate.readthedocs.io/)\n", "- [BrainUnit Documentation](https://brainunit.readthedocs.io/)" ] } ], "metadata": { "kernelspec": { "display_name": "Ecosystem-py", "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.13" } }, "nbformat": 4, "nbformat_minor": 5 }