The leaky integrate-and-fire neuron

A spiking neuron model with live membrane trace, noise, and an f-I curve that builds up as you explore.

The simplest spiking neuron model, from the webinar for the German Neuroscience Olympiad 2020. Everything on this page runs in your browser; nothing to install. Change a slider while a simulation is running and it reacts immediately.

exFont = "16px " + getComputedStyle(document.body).fontFamily
exFg = () => getComputedStyle(document.body).color
mkCanvas = (W, H) => {
  const c = DOM.context2d(W, H);
  c.canvas.style.width = "100%"; c.canvas.style.maxWidth = W + "px"; c.canvas.style.height = "auto";
  return c;
}
axisBox = (c, x, y, w, h) => { c.strokeStyle = "#999"; c.lineWidth = 1; c.strokeRect(x, y, w, h); }

The neuron’s membrane potential \(V\) integrates its input current \(I\) and leaks back towards rest. Whenever \(V\) reaches the threshold \(V_{\text{th}}\), a spike is emitted and \(V\) is reset.

\[\tau_m \frac{dV}{dt} = (V_{\text{rest}} - V) + R\,I(t)\]

• \(V\): membrane potential in mV. \(V_{\text{rest}} = -65\) mV is the resting potential it leaks back to; after a spike it is reset to \(V_{\text{reset}} = -70\) mV and held there for a refractory period of 2 ms.
• \(I(t)\): input current in nA. With noise switched on, a random Gaussian fluctuation is added at every time step; the slider sets its strength.
• \(\tau_m\): membrane time constant in ms, how quickly \(V\) follows a change in input.
• \(R = 2\) MΩ: input resistance, fixed. \(V_{\text{th}}\): the threshold slider.

viewof lifI = Inputs.range([0, 25], {value: 8, step: 0.5, label: "Input current (nA)"})
viewof lifNoise = Inputs.range([0, 10], {value: 0, step: 0.5, label: "Input noise (0 = off)"})
viewof lifTau = Inputs.range([2, 50], {value: 10, step: 1, label: "Membrane time constant τ (ms)"})
viewof lifThr = Inputs.range([-60, -35], {value: -50, step: 1, label: "Threshold (mV)"})
viewof lifPause = Inputs.toggle({label: "Pause"})
viewof lifReset = Inputs.button("Reset (also clears the f-I points)")

lifState = {
  lifReset;
  const dt = 0.1, win = 300, R = 2, Vrest = -65, Vreset = -70, refr = 2;
  const n = Math.round(win / dt);
  const V = new Float32Array(n).fill(Vrest), Iarr = new Float32Array(n);
  let v = Vrest, refrLeft = 0, t = 0;
  const fi = new Map();
  let key = null, sinceChange = 0, spikesSince = 0, lastSig = 0;
  const gauss = () => { let u = 0; while (u === 0) u = Math.random();
                        return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * Math.random()); };
  while (true) {
    const I0 = viewof lifI.value, sig = viewof lifNoise.value,
          tau = viewof lifTau.value, thr = viewof lifThr.value;
    if (!viewof lifPause.value) {
      const k = `${I0}|${sig > 0}`;
      if (sig > 0 && sig !== lastSig) { for (const [kk, p] of fi) if (p.noisy) fi.delete(kk); }
      if (sig > 0) lastSig = sig;
      if (k !== key) { key = k; sinceChange = 0; spikesSince = 0; }
      for (let s = 0; s < 20; s++) {
        const I = I0 + sig * gauss() / Math.sqrt(dt);
        if (refrLeft > 0) { refrLeft -= dt; v = Vreset; }
        else {
          v += dt / tau * ((Vrest - v) + R * I);
          if (v >= thr) { v = 20; spikesSince++; refrLeft = refr; }
        }
        V.copyWithin(0, 1); V[n - 1] = v;
        Iarr.copyWithin(0, 1); Iarr[n - 1] = I;
        if (v === 20) v = Vreset;
        t += dt; sinceChange += dt;
      }
      if (sinceChange >= 500) fi.set(key, {I: I0, noisy: sig > 0, rate: 1000 * spikesSince / sinceChange});
    }
    yield {V, Iarr, t, win, fi, thr, tau, sig, I0, R, Vrest, refr,
           rate: sinceChange > 0 ? 1000 * spikesSince / sinceChange : 0};
  }
}
lifCanvas = mkCanvas(760, 360)

{
  const {V, Iarr, win, fi, thr, tau, sig, I0, R, Vrest, refr, rate} = lifState;
  const blue = "#1f77b4", orange = "#ff7f0e", c = lifCanvas, fg = exFg();
  const W = 760, H = 360, n = V.length;
  c.clearRect(0, 0, W, H); c.font = exFont;
  // traces, left
  const mL = 80, trR = 470;
  const top = {y0: 12, h: 80, lo: -10, hi: 35};
  const bot = {y0: 112, h: 200, lo: -80, hi: 30};
  const sx = i => mL + (trR - mL) * i / (n - 1);
  const sy = (p, v) => p.y0 + p.h * (1 - (v - p.lo) / (p.hi - p.lo));
  for (const p of [top, bot]) axisBox(c, mL, p.y0, trR - mL, p.h);
  c.fillStyle = fg; c.textAlign = "right";
  c.fillText("I (nA)", mL - 8, top.y0 + top.h / 2 + 5);
  c.fillText("V (mV)", mL - 8, bot.y0 + bot.h / 2 + 5);
  c.fillText(thr, mL - 8, sy(bot, thr) + 5); c.fillText("-65", mL - 8, sy(bot, -65) + 5);
  c.textAlign = "center"; c.fillText(`last ${win} ms`, (mL + trR) / 2, H - 14);
  c.textAlign = "right"; c.fillText(`${rate.toFixed(0)} spikes / s`, trR - 8, bot.y0 + 20);
  c.setLineDash([4, 4]); c.strokeStyle = "red"; c.beginPath(); c.moveTo(mL, sy(bot, thr)); c.lineTo(trR, sy(bot, thr)); c.stroke(); c.setLineDash([]);
  c.strokeStyle = "#888"; c.lineWidth = 1; c.beginPath();
  for (let i = 0; i < n; i++) { const y = sy(top, Math.max(top.lo, Math.min(top.hi, Iarr[i]))); i ? c.lineTo(sx(i), y) : c.moveTo(sx(0), y); }
  c.stroke();
  c.strokeStyle = sig > 0 ? orange : blue; c.lineWidth = 1.5; c.beginPath();
  for (let i = 0; i < n; i++) i ? c.lineTo(sx(i), sy(bot, V[i])) : c.moveTo(sx(0), sy(bot, V[0]));
  c.stroke();
  // f-I curve, right
  const fP = {x0: 560, y0: 12, w: 180, h: 300};
  const Imax = 25, fmax = Math.max(100, ...Array.from(fi.values()).map(p => p.rate)) * 1.1;
  const fx = I => fP.x0 + fP.w * I / Imax, fy = f => fP.y0 + fP.h * (1 - f / fmax);
  axisBox(c, fP.x0, fP.y0, fP.w, fP.h);
  c.fillStyle = fg; c.textAlign = "center";
  c.fillText("input (nA)", fP.x0 + fP.w / 2, H - 14);
  c.fillText("0", fx(0), fP.y0 + fP.h + 20); c.fillText(Imax, fx(Imax), fP.y0 + fP.h + 20);
  c.save(); c.translate(fP.x0 - 44, fP.y0 + fP.h / 2); c.rotate(-Math.PI / 2); c.fillText("spikes / s", 0, 0); c.restore();
  c.textAlign = "right"; c.fillText("0", fP.x0 - 6, fy(0) + 5); c.fillText(fmax.toFixed(0), fP.x0 - 6, fy(fmax) + 5);
  c.setLineDash([3, 3]); c.strokeStyle = blue; c.lineWidth = 1; c.beginPath(); let started = false;
  for (let I = 0; I <= Imax; I += 0.1) {
    const d = R * I - (thr - Vrest); if (d <= 0) continue;
    const f = Math.min(fmax, 1000 / (refr + tau * Math.log(R * I / d)));
    started ? c.lineTo(fx(I), fy(f)) : c.moveTo(fx(I), fy(f)); started = true;
  }
  c.stroke(); c.setLineDash([]);
  for (const [k, p] of fi) { c.fillStyle = p.noisy ? orange : blue; c.beginPath(); c.arc(fx(p.I), fy(p.rate), 5, 0, 2 * Math.PI); c.fill(); }
  c.strokeStyle = sig > 0 ? orange : blue; c.lineWidth = 2; c.beginPath(); c.arc(fx(I0), fy(Math.min(rate, fmax)), 8, 0, 2 * Math.PI); c.stroke();
  c.textAlign = "left"; c.fillStyle = blue; c.fillText("noise-free", fP.x0 + 8, fP.y0 + 22);
  c.fillStyle = orange; c.fillText(sig > 0 ? `noise ${sig}` : "noise (off)", fP.x0 + 8, fP.y0 + 44);
  return c.canvas;
}

What you see. Left, top: the input current \(I\) in grey, over the last 300 ms. Left, bottom: the membrane potential \(V\), blue when the input is noise-free, orange when noise is on. The red dashed line is the threshold; the spikes are drawn as vertical strokes up to +20 mV. The number in the corner is the current firing rate.

Right: the f-I curve, firing rate against input current. Every input strength you try adds a dot once the neuron has run for half a second at that setting; blue dots are noise-free measurements, orange dots are measurements at the current noise level (changing the noise level clears them). The open ring marks the setting you are looking at now. The blue dashed line is the exact rate of the noise-free neuron, \(f = 1 / \left(t_{\text{ref}} + \tau_m \ln \frac{RI}{RI - (V_{\text{th}} - V_{\text{rest}})}\right)\), which is zero below \(I = (V_{\text{th}} - V_{\text{rest}})/R\). Noise lets the neuron fire below that point and rounds off the curve.

Try: increase the current until the neuron starts to fire, then add noise at a sub-threshold current. From the webinar for the German Neuroscience Olympiad 2020. Notebook on GitHub · Open in Google Colab