Simuler l'activité neurale avec Brian2

Des études qui simulent l'activité neuronale sur un ordinateur sont en cours depuis un certain temps. NEURON de l'Université de Yale est célèbre en tant que simulateur, mais il existe divers autres logiciels.

Cette fois, j'utiliserai un logiciel appelé Brian2, qui a été publié sur eLife l'année dernière (2019).

• Il est facile de se tromper, mais le nom est Brian **, pas ** Brain.

Page d'accueil: https://briansimulator.org/ GitHub：https://github.com/brian-team/brian2 Article: https://elifesciences.org/articles/47314 Le développeur est l'Université de la Sorbonne en France.

Installation

L'environnement est Ubuntu 16.04 Anaconda Python 3.6 est.

Il semble que l'installation puisse être effectuée avec conda ou pip.

pip install brian2

Vous l'avez maintenant installé. La version était brian 2-2.3.0.2.

Dans la section suivante, j'essaierai les bases en me référant au Document Tutorial.

Essayez de bouger

Tout d'abord, faisons une simple simulation du potentiel de membrane.

Importer. (Dans cette section, par souci de clarté qui est le module, j'ose l'importer normalement au lieu de from brian2 import * selon le manuel.)

import brian2

** Brian2 a une unité physique en tant que module, et vous pouvez définir Hz, ms, etc. tels quels. ** ** Vous pouvez l'utiliser pour décrire de manière concise les paramètres et les constantes. De plus, il est possible d'éviter les erreurs de réglage car une erreur se produira si les unités physiques ne sont pas alignées pendant le calcul.

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

Pour démarrer la simulation, insérez d'abord start_scope ().

brian2.start_scope()

L'équation différentielle (qui définit le changement de potentiel de membrane) semble être définie comme un type String.

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

Le volt ci-dessus est l'unité physique de la variable. Exprimé en unités SI. Ici, le potentiel de membrane est une variable. (sauf réfractaire) est nécessaire lors de l'utilisation de réfractaires.

Les cellules nerveuses sont définies dans le module «Neuron Group».

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

Le premier argument est le nombre de cellules nerveuses. Cette fois, je l'ai mis avec un. Le deuxième argument est l'équation différentielle du potentiel de membrane. Les autres arguments sont seuil est le potentiel de seuil qui devient un pic reset est le potentiel de réinitialisation après le pic réfractaire est une période réfractaire méthode est une méthode de calcul numérique Est réglé.

Réglez la valeur initiale du potentiel de membrane.

G.v = -70 * brian2.mV

Vous pouvez surveiller avec StateMonitor.

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

La simulation est lancée par run (<time>).

brian2.run(50*brian2.ms)

Vous pouvez maintenant simuler.

Tracez les résultats.

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

Ce résultat est le résultat de la simulation des pics de neurones dans le modèle LIF. (Bien qu'il n'y ait pas de potentiel de crête.)

Vous connaissez maintenant le déroulement de la simulation.

En tant qu'évolution, il semble qu'il soit également possible de traiter les équations différentielles de probabilité incluant le bruit en utilisant «xi» (variable de probabilité de distribution normale standard).

Simulation de pic de plusieurs cellules nerveuses

Ensuite, nous simulerons les pics de plusieurs cellules nerveuses. Cette fois, je donnerai à chaque cellule un potentiel d'entrée différent (I).

Je vais commencer par l'importation.

from brian2 import *

start_scope()

N = 100 #Nombre de cellules
tau = 10*ms #Constante de temps de la membrane
v0 = -50*mV #Potentiel de film de repos

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

Utilisez SpikeMonitor si vous ne voulez voir que des pointes, pas des changements de potentiel de membrane.

M = SpikeMonitor(G)

Définissez une entrée différente pour chaque cellule.

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

i est l'indice de la cellule. Vous avez maintenant défini différentes entrées.

courir

duration = 1000*ms
run(duration)

Créez un tracé raster.

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

Au fur et à mesure que l'indice de cellule augmente, le potentiel d'entrée augmente, donc il y a plus de pics.

Je vais également faire une courbe F-I que vous voyez souvent.

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

c'est complet. On dit que cela est similaire à la fonction ReLU.

Pour simuler un circuit neuronal

Je vais omettre les détails, mais il semble que vous puissiez facilement simuler le circuit neuronal.

Les synapses peuvent être définies dans le module Synapses. La méthode connect connecte les cellules. (Quelle cellule connecter à quelle cellule)

Il est possible de définir une équation différentielle pour la force des synapses, et il semble qu'un modèle STDP puisse également être créé.

De plus, il semble que vous puissiez définir le réseau avec le module Network.

Impressions

Je pensais que c'était facile à utiliser car il avait beaucoup de fonctions de simulation.

Il existe de nombreux autres exemples dans la documentation. https://brian2.readthedocs.io/en/stable/examples/index.html Il y avait aussi un exemple de modèle de compartiment. J'aimerais aussi les essayer.

• Une addition En janvier de cette année, Brian2GeNN a été annoncé. https://www.nature.com/articles/s41598-019-54957-7 Il semble que le GPU puisse désormais également être utilisé.