[PYTHON] Simulieren Sie neuronale Aktivitäten mit Brian2

Studien, die neuronale Aktivitäten auf einem Computer simulieren, sind seit einiger Zeit im Gange. NEURON der Yale University ist als Simulator bekannt, es gibt jedoch verschiedene andere Software.

Dieses Mal werde ich eine Software namens Brian2 verwenden, die letztes Jahr (2019) bei eLife veröffentlicht wurde.

• Es ist leicht, einen Fehler zu machen, aber der Name ist Brian **, nicht ** Brain.

Homepage: https://briansimulator.org/ GitHub：https://github.com/brian-team/brian2 Papier: https://elifesciences.org/articles/47314 Entwickler ist die Sorbonne University in Frankreich.

Installation

Die Umwelt ist Ubuntu 16.04 Anaconda Python 3.6 ist.

Es scheint, dass die Installation entweder mit Conda oder Pip erfolgen kann.

pip install brian2

Sie haben es jetzt installiert. Die Version war Brian 2-2.3.0.2.

Im nächsten Abschnitt werde ich die Grundlagen unter Bezugnahme auf Document Tutorial ausprobieren.

Versuche dich zu bewegen

Lassen Sie uns zunächst eine einfache Membranpotentialsimulation durchführen.

Importieren. (In diesem Abschnitt wage ich es aus Gründen der Klarheit, das Modul zu sein, es normal zu importieren, anstatt "aus brian2 import *" gemäß Handbuch.)

import brian2

** Brian2 hat eine physikalische Einheit als Modul, und Sie können "Hz", "ms" usw. so definieren, wie sie sind. ** ** ** Sie können damit Parameter und Konstanten präzise beschreiben. Darüber hinaus können Einstellungsfehler vermieden werden, da ein Fehler auftritt, wenn die physischen Einheiten während der Berechnung nicht ausgerichtet werden.

v0 =  -10 * brian2.mV
tau = 10 * brian2.ms

Um die Simulation zu starten, fügen Sie zuerst start_scope () ein.

brian2.start_scope()

Die Differentialgleichung (die die Änderung des Membranpotentials definiert) scheint als String-Typ definiert zu sein.

eqs = 'dv/dt = (v0-v)/tau : volt (unless refractory)'

Das obige Volt ist die physikalische Einheit der Variablen. In SI-Einheiten ausgedrückt. Hier ist das Membranpotential eine Variable. (sofern nicht feuerfest) ist bei Verwendung von feuerfestem Material erforderlich.

Nervenzellen werden im Modul "Neuron Group" definiert.

G = brian2.NeuronGroup(1, eqs, threshold='v > -40*mV', reset='v = -60*mV', refractory=5*brian2.ms, method='exact')

Das erste Argument ist die Anzahl der Nervenzellen. Diesmal habe ich es mit einem eingestellt. Das zweite Argument ist die Differentialgleichung des Membranpotentials. Die anderen Argumente sind Schwelle ist das Schwellenpotential, das zu einer Spitze wird Zurücksetzen ist das Rücksetzpotential nach der Spitze Feuerfest ist eine Feuerfestperiode Methode ist eine numerische Berechnungsmethode Ist eingestellt.

Stellen Sie den Anfangswert des Membranpotentials ein.

G.v = -70 * brian2.mV

Sie können mit StateMonitor überwachen.

M = brian2.StateMonitor(G, 'v', record=True)

Die Simulation wird mit run (<time>) gestartet.

brian2.run(50*brian2.ms)

Sie können jetzt simulieren.

Zeichnen Sie die Ergebnisse.

brian2.plot(M.t/brian2.ms, M.v[0]/brian2.mV)
brian2.xlabel('Time (ms)')
brian2.ylabel('Ptential (mV)');

Dieses Ergebnis ist das Ergebnis der Simulation der Spitzen von Neuronen im LIF-Modell. (Obwohl es kein Spitzenpotential gibt.)

Jetzt kennen Sie den Ablauf der Simulation.

Als eine Entwicklung scheint es auch möglich zu sein, Wahrscheinlichkeitsdifferentialgleichungen einschließlich Rauschen unter Verwendung von "xi" (Wahrscheinlichkeitsvariable der Standardnormalverteilung) zu handhaben.

Spike-Simulation mehrerer Nervenzellen

Als nächstes simulieren wir die Spitzen mehrerer Nervenzellen. Dieses Mal werde ich jeder Zelle ein anderes Eingangspotential geben (I).

Ich werde mit dem Import beginnen.

from brian2 import *

start_scope()

N = 100 #Anzahl der Zellen
tau = 10*ms #Membranzeitkonstante
v0 = -50*mV #Ruhefilmpotential

eqs = '''
dv/dt = (v0-v+I)/tau : volt (unless refractory)
I : volt
'''

G = NeuronGroup(N, eqs, threshold='v>-40*mV', reset='v=-60*mV', refractory=1*ms, method='exact')
G.v = -70*mV

Verwenden Sie "SpikeMonitor", wenn Sie nur Spitzen sehen möchten, keine Änderungen des Membranpotentials.

M = SpikeMonitor(G)

Definieren Sie für jede Zelle eine andere Eingabe.

I_max = 40*mV
G.I = 'i*I_max/(N-1)'

i ist der Index der Zelle. Sie haben jetzt verschiedene Eingänge definiert.

Lauf

duration = 1000*ms
run(duration)

Erstellen Sie ein Rasterplot.

plot(M.t/ms, M.i, '.k')
xlabel('Time (ms)')
ylabel('Neuron index');

Wenn der Zellenindex steigt, steigt das Eingangspotential, so dass es mehr Spitzen gibt.

Ich werde auch eine F-I-Kurve machen, die Sie oft sehen.

plot(G.I/mV, M.count/duration)
xlabel('Input (mV)')
ylabel('Firing rate (sp/s)');

Es ist vollständig. Es wird gesagt, dass dies der ReLU-Funktion ähnlich ist.

Eine neuronale Schaltung simulieren

Ich werde die Details weglassen, aber es scheint, dass Sie den neuronalen Schaltkreis leicht simulieren können.

Synapsen können im Modul "Synapsen" definiert werden. Die "connect" -Methode verbindet die Zellen. (Welche Zelle soll mit welcher Zelle verbunden werden?)

Es ist möglich, eine Differentialgleichung für die Stärke von Synapsen zu definieren, und es scheint, dass auch ein STDP-Modell erstellt werden kann.

Außerdem können Sie das Netzwerk anscheinend mit dem Modul "Netzwerk" definieren.

Impressionen

Ich fand es einfach zu bedienen, da es viele Funktionen für die Simulation hatte.

Es gibt viele andere Beispiele in der Dokumentation. https://brian2.readthedocs.io/en/stable/examples/index.html Es gab auch ein Beispiel für ein Abteilmodell. Ich würde diese auch gerne ausprobieren.

• Ergänzung Im Januar dieses Jahres wurde Brian2GeNN angekündigt. https://www.nature.com/articles/s41598-019-54957-7 Es scheint, dass die GPU jetzt auch verwendet werden kann.