Python MNE ist ein Open-Source-Tool zur Analyse und Visualisierung von zerebralen Magnetdiagrammen (MEG) und Gehirnwellen (EEG). Man kann sagen, dass es sehr vielseitig ist, da es auf die Datenformate vieler Geräte angewendet werden kann. Folgen Sie in diesem Artikel den grundlegendsten Tutorials. Das MEG- und EEG-MNE-Analyseverfahren wird erläutert.

Ausführungsumgebung

Mac OS 10.15.3
Python 3.6.5
mne 0.20.4

Installation

Sie können es entweder mit Anaconda oder pip installieren. Auf der offiziellen Seite wird Anaconda empfohlen.

Für Anaconda


conda install -c conda-forge mne

Für pip


pip install -U mne

Außerdem scheinen GPU-Einstellungen möglich zu sein, sodass das Filtern und Abtasten einige Zeit in Anspruch nimmt. Wenn es dauert, ist es möglicherweise besser, es einzustellen.


$ conda install cupy
$ MNE_USE_CUDA=true python -c "import mne; mne.cuda.init_cuda(verbose=True)"
Enabling CUDA with 1.55 GB available memory

>>> mne.utils.set_config('MNE_USE_CUDA', 'true')  
# mne.io.Raw.filter()Usw._jobs='cuda'geben

Tutorial zur MEG / EEG-Analyse

Typisch für die Analyse von Gehirnwellen entlang dieses Tutorials Ich werde die grundlegende Verarbeitung und die grundlegende Datenstruktur von MNE erläutern. Ich werde es kurz erläutern. Wenn Sie also Kenntnisse in Englisch und Gehirnwellenanalyse haben, sollten Sie die Originalseite lesen.

Analyseverfahren

[Daten laden](# Daten laden)
[Vorverarbeitung](# Vorverarbeitung)
[Ereigniserkennung](# Ereigniserkennung)
[In Epoche schneiden](# In Epoche schneiden)
[Zeit-Frequenz-Analyse](# Zeit-Frequenz-Analyse)
[Schätzung der evozierten Reaktion](# Schätzung der evozierten Reaktion)

Modulimport

import os
import numpy as np
import mne

Lade Daten

Laden Sie die in mne bereitgestellten Beispieldaten (Liste aller Datensätze). Übrigens haben MEG und EEG mehrere Dateiformate für jedes Gerät, aber es gibt eine Funktion zum Laden dieser Daten (Unterstützte Datenformate. Stable / Übersicht / Implementierung.html # Datenformate))

sample_data_folder = mne.datasets.sample.data_path()
sample_data_raw_file = os.path.join(sample_data_folder, 'MEG', 'sample',
                                    'sample_audvis_filt-0-40_raw.fif')
raw = mne.io.read_raw_fif(sample_data_raw_file)

Dieses Mal verwenden wir die bei 40 Hz tiefpassgefilterten Daten mit dem Namen "sample_audvis_filt-0-40_raw.fif". Das Herunterladen der Daten (ca. 1,54 GB) dauerte ca. 1 Minute.

Die Funktion mne.io.read_raw_fif () liest die Daten der MNE-Datenstruktur namens Raw-Objekt aus der Fif-Formatdatei.

Übrigens wird im Experiment dieser Daten dem Probanden alle 750 ms zufällig ein visueller Reiz und ein auditorischer Reiz nach links und rechts präsentiert. Manchmal wird auch ein lachendes Gesicht auf dem Bildschirm angezeigt, und das Motiv drückt einen Knopf, wenn es es sieht. Die Präsentation dieser Reize wird als Ereignis bezeichnet.

Zeigen Sie das geladene Objekt an.

print(raw)
print(raw.info)

# output
<Raw | sample_audvis_filt-0-40_raw.fif, 376 x 41700 (277.7 s), ~3.6 MB, data not loaded>
<Info | 15 non-empty values
 bads: 2 items (MEG 2443, EEG 053)
 ch_names: MEG 0113, MEG 0112, MEG 0111, MEG 0122, MEG 0123, MEG 0121, MEG ...
 chs: 204 GRAD, 102 MAG, 9 STIM, 60 EEG, 1 EOG
 custom_ref_applied: False
 dev_head_t: MEG device -> head transform
 dig: 146 items (3 Cardinal, 4 HPI, 61 EEG, 78 Extra)
 file_id: 4 items (dict)
 highpass: 0.1 Hz
 hpi_meas: 1 item (list)
 hpi_results: 1 item (list)
 lowpass: 40.0 Hz
 meas_date: 2002-12-03 19:01:10 UTC
 meas_id: 4 items (dict)
 nchan: 376
 projs: PCA-v1: off, PCA-v2: off, PCA-v3: off, Average EEG reference: off
 sfreq: 150.2 Hz
>

MNE umfasst Raw, Epochen /mne.Epochs.html#mne.Epochs), Evoked Daten werden von Objekten verwaltet, die als Objekte bezeichnet werden. Diese unterscheiden sich durch die zeitliche Aufteilung der Daten, und Raw enthält die Daten der gesamten Zeit vom Beginn bis zum Ende der Gehirnwellenaufzeichnung, und es ist gut zu glauben, dass dies der Zustand ist, bevor er durch das Ereignis getrennt wird. Ich denke. raw.info enthält Informationen wie die Anzahl der Kanäle, Namen und Abtastraten von raw.

Die Leistungsspektraldichte (PSD) dieses Raw-Objekts und die Wellenform für jeden Sensor werden angezeigt. plot () kann in einer interaktiven Shell gescrollt und skaliert werden.

raw.plot_psd(fmax=50)
raw.plot(duration=5, n_channels=30)

Vorverarbeitung

Bei der Rauschverarbeitung der EEG / MEG-Analyse wird die standardmäßige unabhängige Komponentenanalyse (ICA) durchgeführt. Einfach ausgedrückt, wird durch Zerlegen eines Mehrkanalsignals in unabhängige Komponenten eine Verarbeitung durchgeführt, die Dinge entfernt, die unabhängig von der Gehirnaktivität sind, wie z. B. Stromversorgungsrauschen und Blinken.

Hier werden für das Signal von 364 Kanälen nach der Zerlegung in 20 unabhängige Komponenten "[1, 2]" und der Index der zu entfernenden Komponente angegeben (die tatsächliche Entfernung ist die folgende "ica.apply" Es wird von (raw) ) gemacht. Zeigen Sie die Informationen unabhängiger Komponenten mit ica_properties ()` an.

# set up and fit the ICA
ica = mne.preprocessing.ICA(n_components=20, random_state=97, max_iter=800)
ica.fit(raw)
ica.exclude = [1, 2]  # details on how we picked these are omitted here
ica.plot_properties(raw, picks=ica.exclude)

# output
Fitting ICA to data using 364 channels (please be patient, this may take a while)
Inferring max_pca_components from picks
Selecting by number: 20 components
Fitting ICA took 2.4s.
    Using multitaper spectrum estimation with 7 DPSS windows
138 matching events found
No baseline correction applied
Not setting metadata
0 projection items activated
0 bad epochs dropped
138 matching events found
No baseline correction applied
Not setting metadata
0 projection items activated
0 bad epochs dropped

Wenden Sie das ICA-Objekt auf das Raw-Objekt an, um das Signal mit der angegebenen unabhängigen Komponente zu entfernen.

orig_raw = raw.copy()
raw.load_data()
ica.apply(raw)

Wenn der Frontkanal angezeigt wird, wird das Rauschen entfernt, wie in den folgenden beiden Abbildungen gezeigt.

# show some frontal channels to clearly illustrate the artifact removal
chs = ['MEG 0111', 'MEG 0121', 'MEG 0131', 'MEG 0211', 'MEG 0221', 'MEG 0231',
       'MEG 0311', 'MEG 0321', 'MEG 0331', 'MEG 1511', 'MEG 1521', 'MEG 1531',
       'EEG 001', 'EEG 002', 'EEG 003', 'EEG 004', 'EEG 005', 'EEG 006',
       'EEG 007', 'EEG 008']
chan_idxs = [raw.ch_names.index(ch) for ch in chs]
orig_raw.plot(order=chan_idxs, start=12, duration=4)
raw.plot(order=chan_idxs, start=12, duration=4)

# output
Reading 0 ... 41699  =      0.000 ...   277.709 secs...
Transforming to ICA space (20 components)
Zeroing out 2 ICA components

Ereigniserkennung

Diese Beispieldaten enthalten den sogenannten STIM-Kanal, der Daten zum Ereignistyp und seiner Zeit enthält. Dieses Mal ist der Kanal mit dem Namen "STI 014" anwendbar. Geben Sie ihn an und rufen Sie das Ereignis des Experiments ab.

events = mne.find_events(raw, stim_channel='STI 014')
print(events[:5])  # show the first 5

# output
319 events found
Event IDs: [ 1  2  3  4  5 32]

[[6994    0    2]
 [7086    0    3]
 [7192    0    1]
 [7304    0    4]
 [7413    0    2]]

events ist ein Numpy-Array, die erste Spalte repräsentiert die Abtastzeit und die letzte Spalte repräsentiert den Ereignistyp (ID) (0 in der Mitte kann ignoriert werden). Hier scheint es ein Ereignis mit der ID "[1 2 3 4 5 32]" zu geben.

Event ID	Condition
1	auditory stimulus (tone) to the left ear
2	auditory stimulus (tone) to the right ear
3	visual stimulus (checkerboard) to the left visual field
4	visual stimulus (checkerboard) to the right visual field
5	smiley face (catch trial)
32	subject button press

Die Ereignis-ID und die Beschreibung des Ereignisses werden in einem Wörterbuchtyp gespeichert. Der Schlüssel hier kann übrigens eine beliebige Zeichenfolge sein.

event_dict = {'auditory/left': 1, 'auditory/right': 2, 'visual/left': 3,
              'visual/right': 4, 'smiley': 5, 'buttonpress': 32}

Zeichnen wir den Präsentationszeitpunkt jedes Ereignisses auf der Zeitachse. Die zuvor durch event_id = even_dict definierte ID und der Ereignisname entsprechen einander im Plot.

fig = mne.viz.plot_events(events, event_id=event_dict, sfreq=raw.info['sfreq'],
                          first_samp=raw.first_samp)

In eine Epoche ausschneiden

Bei der MEG / EEG-Analyse wird das Signal, insbesondere bei der Untersuchung der Reaktion auf einen bestimmten Stimulus, in Einheiten unterteilt, die als Epochen bezeichnet werden, und als ein Datenelement behandelt. Durch Ausschneiden eines bestimmten Abschnitts vor und nach dem Stimulus wird er zu einer Dateneinheit. Dieser Schneidvorgang wird als Epochen bezeichnet. Rohobjekte werden während der Aufzeichnung für die gesamte Zeit verbunden, aber nur der Teil, der auf den Stimulus reagiert, wird ausgeschnitten und im Datentyp namens Epochs-Objekt gespeichert.

In der Epoche wird häufig ein Prozess ausgeführt, der als Schwellenwertunterdrückung bezeichnet wird. Dies bedeutet, dass bei einem Signal, das während der relevanten Zeit zu laut ist, dieser Teil stark verrauscht ist und von den Daten ausgeschlossen wird. Bestimmen Sie die Kriterien für den Ausschluss.

reject_criteria = dict(mag=4000e-15,     # 4000 fT
                       grad=4000e-13,    # 4000 fT/cm
                       eeg=150e-6,       # 150 µV
                       eog=250e-6)       # 250 µV

Erstellen Sie als Nächstes ein Epochs-Objekt aus dem Raw-Objekt. Die Argumente von mne.Epochs hier sind wie folgt.

raw: Rohobjekt mit Signaldaten
events: numpy Array mit Zeit- und Ereignis-ID-Informationen
event_id: Wörterbuchtyp, der Ereignis-IDs mit ihren Namen verknüpft
tmin: Wie viele Sekunden der Stimuluspräsentation müssen ausgeschnitten werden (vor der Stimuluspräsentation ein Minus hinzufügen)
tmax: Wie viele Sekunden, nachdem der Stimulus präsentiert wurde, um die Daten auszuschneiden
ablehnen: Kriterien für den Datenausschluss

epochs = mne.Epochs(raw, events, event_id=event_dict, tmin=-0.2, tmax=0.5,
                    reject=reject_criteria, preload=True)

# output
319 matching events found
Applying baseline correction (mode: mean)
Not setting metadata
Created an SSP operator (subspace dimension = 4)
4 projection items activated
Loading data for 319 events and 106 original time points ...
    Rejecting  epoch based on EOG : ['EOG 061']
    Rejecting  epoch based on EOG : ['EOG 061']
    Rejecting  epoch based on MAG : ['MEG 1711']
    Rejecting  epoch based on EOG : ['EOG 061']
    Rejecting  epoch based on EOG : ['EOG 061']
    Rejecting  epoch based on MAG : ['MEG 1711']
    Rejecting  epoch based on EEG : ['EEG 008']
    Rejecting  epoch based on EOG : ['EOG 061']
    Rejecting  epoch based on EOG : ['EOG 061']
    Rejecting  epoch based on EOG : ['EOG 061']
10 bad epochs dropped

Es scheint, dass diesmal 10 Epochen ausgeschlossen wurden.

Da der Zeitpunkt des Drückens der Taste des Motivs diesmal nicht behandelt wird, wird nur das audiovisuelle Stimulationsereignis angestrebt. Um zu verhindern, dass die Anzahl der Daten zwischen Bedingungen verzerrt wird, wird die Anzahl jeder Bedingung durch Löschen der Ereignisse einer großen Anzahl von Bedingungen mit "epochs.equalize_event_counts ()" vereinheitlicht.

conds_we_care_about = ['auditory/left', 'auditory/right',
                       'visual/left', 'visual/right']
epochs.equalize_event_counts(conds_we_care_about)  # this operates in-place

In event_dict wurde es alsauditory / left' und auditory / right angegeben, aber wenn es an das Epochs-Objekt übergeben wird, zeigt es auf beide, wenn audittory angegeben ist. Hier teilen wir es in Daten für auditive Reize und Daten für visuelle Reize auf.

aud_epochs = epochs['auditory']
vis_epochs = epochs['visual']
del raw, epochs  # free up memory

Der Kanal wird durch die Hördaten spezifiziert und die hinzugefügte durchschnittliche Wellenform mit derselben Stimuluspräsentationszeit wird angezeigt.

aud_epochs.plot_image(picks=['MEG 1332', 'EEG 021'])

# output
136 matching events found
No baseline correction applied
Not setting metadata
0 projection items activated
0 bad epochs dropped
136 matching events found
No baseline correction applied
Not setting metadata
0 projection items activated
0 bad epochs dropped

Da die Zeitreihen-Wellenformdaten in Form eines Numpy-Arrays mit der Methode "get_data ()" des Epochs-Objekts erfasst werden können, ist es als Ergänzung möglich, sie in das maschinelle Lernmodell einzugeben, indem für jede Bedingung ein Array erstellt wird. ..

aud_epochs.get_data().shape

(136, 376, 106) # (Epoche, Kanal, Zeit)

Gleiches gilt für die folgende Frequenzverarbeitung, die ein Numpy-Array zurückgibt.

Zeit-Frequenz-Analyse

Eine Zeit-Frequenz-Analyse wird durchgeführt, um die Beziehung zwischen Zeit und Frequenz vor und nach der Stimuluspräsentation in der MEG / EEG-Wellenform zu untersuchen. Hier wird die Reaktion auf Hörreize durch Wavelet-Analyse berechnet und aufgezeichnet. Wie in der Farbleiste gezeigt, ist die Amplitude dieser Frequenz zu diesem Zeitpunkt umso größer, je dunkler das Rot ist. (Detaillierteres Beispiel)

frequencies = np.arange(7, 30, 3)
power = mne.time_frequency.tfr_morlet(aud_epochs, n_cycles=2, return_itc=False,
                                      freqs=frequencies, decim=3)
power.plot(['MEG 1332'])

# output
No baseline correction applied

Schätzung der evozierten Reaktion

Als Datentyp von MNE wird das evozierte Objekt durch Mitteln des Epochs-Objekts erhalten. MEG / EEG-Daten weisen neben der Gehirnaktivität viel anderes Rauschen auf, und der Unterschied zwischen den Zuständen wird häufig durch Durchführen einer Additionsmittelung untersucht.

Hier ist die Differenz zwischen den hinzugefügten Wellenformen der Hördaten und den visuellen Daten aufgetragen.

aud_evoked = aud_epochs.average()
vis_evoked = vis_epochs.average()

mne.viz.plot_compare_evokeds(dict(auditory=aud_evoked, visual=vis_evoked),
                             legend='upper left', show_sensors='upper right')

Evozierte Objekte verfügen über Methoden zur weiteren Analyse. Wenn Sie die Wellenform für jeden Kanal anzeigen, sehen Sie den Rundlauf (P200), der in 100 ms (N100) im vorderen Kanal negativ wird und eine positive Spitze um 200 ms aufweist.

aud_evoked.plot_joint(picks='eeg')

Sie können die Verteilung auch auf der Kopfhaut anzeigen, die als Topographie bezeichnet wird. Hier ist zu sehen, dass Gehirnwellen mit positiven Potentialen für Rot und negativen Potentialen für Blau wie folgt auf der Kopfhaut beobachtet werden.

aud_evoked.plot_topomap(times=[0., 0.08, 0.1, 0.12, 0.2], ch_type='eeg')

Um den Unterschied zwischen den Bedingungen zu erkennen, erstellt mne.combine_evoked () ein evoziertes Objekt mit den Daten der beiden Bedingungsunterschiede (zu diesem Zeitpunkt erhält ein Objekt ein Minuszeichen). Wenn Sie die Wellenform dieses Objekts anzeigen, können Sie die Wellenform der Differenz zwischen den beiden Bedingungen sehen.

evoked_diff = mne.combine_evoked([aud_evoked, -vis_evoked], weights='equal')
evoked_diff.pick_types('mag').plot_topo(color='r', legend=False)

abschließend

Hier werden nur die Grundfunktionen vorgestellt, aber es gibt viele Tutorial und [Beispiel](https: // mne.) Auf der offiziellen MNE-Seite. tools / stabile / auto_examples / index.html) ist verfügbar. Weitere Informationen finden Sie im ersten Schritt.

Da Python über viele Bibliotheken für Statistik und maschinelles Lernen verfügt, wird es meiner Meinung nach einfacher sein, maschinelles MEG / EEG-Lernen durchzuführen.

Gehirnwellenanalyse mit Python: Python MNE-Tutorial