メニュー
Full EEG/MEG analysis pipeline with MNE-Python: preprocessing, ICA artifact removal, ERP computation, time-frequency analysis, and resting-state power spectral density.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/xjtulyc/awesome-rosetta-skills --skill mne-eegコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SKILL.md を表示中
SOC 職業分類に基づく
| name | mne-eeg |
| description | Full EEG/MEG analysis pipeline with MNE-Python: preprocessing, ICA artifact removal, ERP computation, time-frequency analysis, and resting-state power spectral density. |
| tags | ["neuroscience","eeg","mne-python","erp","time-frequency","signal-processing"] |
| version | 1.0.0 |
| authors | [{"name":"awesome-rosetta-skills contributors","github":"@awesome-rosetta-skills"}] |
| license | MIT |
| platforms | ["claude-code","codex","gemini-cli","cursor"] |
| dependencies | ["mne>=1.5.0","numpy>=1.24.0","scipy>=1.10.0","matplotlib>=3.7.0","pandas>=2.0.0","scikit-learn>=1.3.0"] |
| last_updated | 2026-03-17 |
MNE-Python is the standard open-source toolkit for analyzing M/EEG data. This skill provides a complete pipeline from raw file loading through preprocessing, epoching, ERP computation, time-frequency analysis, and basic source localization. All functions follow MNE idioms and produce publication-ready figures.
| Format | Extension | Notes |
|---|---|---|
| European Data Format | .edf | Common for clinical EEG |
| FIF (Neuromag) | .fif | Native MNE format |
| BrainVision | .vhdr | Requires .eeg + .vmrk |
| EEGLab | .set | Requires .fdt companion file |
| BioSemi | .bdf | High-density ActiveTwo systems |
pip install mne numpy scipy matplotlib pandas scikit-learn
For optional source localization:
pip install mne[hdf5] # HDF5 support
pip install nibabel # NIfTI/FreeSurfer surfaces
import os
import numpy as np
import pandas as pd
import matplotlib
matplotlib.use("Agg") # Non-interactive backend for scripts
import matplotlib.pyplot as plt
import mne
from mne.preprocessing import ICA
from mne.time_frequency import tfr_morlet, psd_array_welch
mne.set_log_level("WARNING") # Reduce verbosity; use "INFO" for debugging
() -> mne.io.BaseRaw:
ext = os.path.splitext(filepath)[].lower()
ext == :
raw = mne.io.read_raw_edf(filepath, preload=preload, verbose=)
ext == :
raw = mne.io.read_raw_fif(filepath, preload=preload, verbose=)
ext (, ):
raw = mne.io.read_raw_brainvision(filepath, preload=preload, verbose=)
ext == :
raw = mne.io.read_raw_eeglab(filepath, preload=preload, verbose=)
ext == :
raw = mne.io.read_raw_bdf(filepath, preload=preload, verbose=)
:
ValueError()
raw.info.get():
montage = mne.channels.make_standard_montage(montage_name)
available = (montage.ch_names)
raw.pick_channels([c c raw.ch_names c available], ordered=)
raw.set_montage(montage, on_missing=)
(
)
raw
() -> mne.io.BaseRaw:
raw = raw.copy()
bad_channels:
raw.info[] = bad_channels
()
notch_freqs = [notch_freq] (notch_freq, (, )) notch_freq
all_notch = []
f notch_freqs:
harmonics = [f * k k (, (raw.info[] // ( * f)) + )]
all_notch.extend(harmonics)
raw.notch_filter(freqs=all_notch, fir_window=, verbose=)
raw.(l_freq=l_freq, h_freq=h_freq, fir_window=, verbose=)
()
reference == :
raw.set_eeg_reference(, projection=, verbose=)
reference == :
raw.set_eeg_reference(, verbose=)
:
raw.set_eeg_reference([reference], verbose=)
raw.info[]:
raw.interpolate_bads(reset_bads=, verbose=)
()
resample_sfreq resample_sfreq != raw.info[]:
raw.resample(resample_sfreq, verbose=)
()
raw
() -> [mne.io.BaseRaw, ICA]:
raw_for_ica = raw.copy()
raw.info.get(, ) < :
raw_for_ica.(l_freq=, h_freq=, verbose=)
ica = ICA(
n_components=n_components,
method=method,
random_state=random_state,
max_iter=,
)
ica.fit(raw_for_ica, verbose=)
()
exclude_indices = []
eog_chs = eog_channels [c c raw.ch_names c.upper().startswith()]
eog_chs:
eog_indices, eog_scores = ica.find_bads_eog(raw_for_ica, ch_name=eog_chs, verbose=)
exclude_indices.extend(eog_indices)
()
:
fp_chs = [c c raw.ch_names c (, , , )]
fp_chs:
eog_indices, _ = ica.find_bads_eog(raw_for_ica, ch_name=fp_chs[:], verbose=)
exclude_indices.extend(eog_indices)
ecg_channel ecg_channel raw.ch_names:
ecg_indices, ecg_scores = ica.find_bads_ecg(raw_for_ica, ch_name=ecg_channel, verbose=)
exclude_indices.extend(ecg_indices)
()
ica.exclude = ((exclude_indices))
()
raw_clean = raw.copy()
ica.apply(raw_clean, verbose=)
raw_clean, ica
() -> mne.Epochs:
reject :
reject = {: }
events, _ = mne.events_from_annotations(raw, event_id=event_id, verbose=)
(events) == stim_channel:
events = mne.find_events(raw, stim_channel=stim_channel, verbose=)
epochs = mne.Epochs(
raw,
events,
event_id=event_id,
tmin=tmin,
tmax=tmax,
baseline=baseline,
reject=reject,
picks=picks,
preload=,
verbose=,
)
()
epochs
() -> [, mne.Evoked]:
conditions = conditions (epochs.event_id.keys())
evokeds = {}
cond conditions:
cond epochs.event_id:
()
ep = epochs[cond]
channels:
ep = ep.copy().pick_channels(channels)
evoked = ep.average()
evoked.comment = cond
evokeds[cond] = evoked
()
evokeds
() -> plt.Figure:
fig, ax = plt.subplots(figsize=figsize)
colors = plt.cm.Set1(np.linspace(, , (evokeds)))
(cond, evoked), color (evokeds.items(), colors):
:
idx = evoked.ch_names.index(channel)
ValueError:
()
data = evoked.data[idx] *
times = evoked.times *
ax.plot(times, data, label=cond, color=color, linewidth=)
ax.axvline(, color=, linewidth=, linestyle=, alpha=)
ax.axhline(, color=, linewidth=, alpha=)
ax.invert_yaxis()
ax.set_xlabel(, fontsize=)
ax.set_ylabel(, fontsize=)
ax.set_title(title , fontsize=)
ax.legend(fontsize=)
ax.grid(, alpha=)
fig.tight_layout()
save_path:
fig.savefig(save_path, dpi=)
fig
() -> :
freqs :
freqs = np.logspace(np.log10(), np.log10(), )
(n_cycles, ):
n_cycles_arr = np.full_like(freqs, n_cycles, dtype=)
:
n_cycles_arr = np.asarray(n_cycles, dtype=)
ep = epochs.copy()
picks:
ep = ep.pick_channels(picks)
power, itc = tfr_morlet(
ep,
freqs=freqs,
n_cycles=n_cycles_arr,
use_fft=,
return_itc=return_itc,
decim=decim,
average=average,
verbose=,
)
()
(power, itc) return_itc (power,)
() -> pd.DataFrame:
BANDS = {
: (, ),
: (, ),
: (, ),
: (, ),
: (, ),
}
spectrum = raw.compute_psd(method=method, fmin=fmin, fmax=fmax, picks=picks ,
verbose=)
psds, freqs = spectrum.get_data(return_freqs=)
psds_uv2 = psds *
ch_names = spectrum.ch_names
records = []
i, ch (ch_names):
row = {: ch}
band, (lo, hi) BANDS.items():
idx = np.where((freqs >= lo) & (freqs < hi))[]
row[band] = np.trapz(psds_uv2[i, idx], freqs[idx])
records.append(row)
pd.DataFrame(records)
An auditory oddball paradigm presents frequent "standard" tones (80%) and rare "deviant" tones (20%). This example preprocesses the raw data, extracts ERPs, and quantifies the N100 (auditory response at ~100 ms) and P300 (cognitive response at ~300 ms on Pz).
# ── Example A ─────────────────────────────────────────────────────────────
# Uses MNE's built-in sample dataset (auditory oddball data)
import mne
import numpy as np
import matplotlib.pyplot as plt
# --- Download MNE sample data (if needed) ------------------------------------
data_path = mne.datasets.sample.data_path()
raw_fif = str(data_path) + "/MEG/sample/sample_audvis_raw.fif"
# --- Load (use only EEG channels) -------------------------------------------
raw = mne.io.read_raw_fif(raw_fif, preload=True, verbose=False)
raw.pick_types(eeg=True, eog=True, stim=True)
print(raw.info)
# --- Preprocess --------------------------------------------------------------
raw_prep = preprocess_raw(
raw,
l_freq=0.5,
h_freq=40.0,
notch_freq=60.0, # 60 Hz (North American power line)
reference="average",
bad_channels=["EEG 053"], # Example bad channel
resample_sfreq=None,
)
# --- ICA artifact removal ---------------------------------------------------
raw_clean, ica = run_ica_artifact_removal(
raw_prep,
n_components=20,
method="fastica",
eog_channels=["EOG 061"],
random_state=0,
)
# --- Epoch around auditory events -------------------------------------------
# MNE sample dataset: event codes 1=LA, 2=RA, 3=LV, 4=RV, 5=smiley, 32=button
event_id = {"auditory/left": 1, "auditory/right": 2}
epochs = epoch_events(
raw_clean,
event_id=event_id,
tmin=-0.2,
tmax=0.5,
baseline=(-0.2, 0),
reject={"eeg": 100e-6},
)
# --- Compute ERPs -----------------------------------------------------------
evokeds = compute_erp(epochs, conditions=["auditory/left", "auditory/right"])
# --- Plot ERPs at Cz ---------------------------------------------------------
fig = plot_erp_comparison(
evokeds,
channel="EEG 059", # Approximately Cz in the sample data
title="Auditory ERP: Left vs Right (Oddball Paradigm)",
save_path="auditory_erp.png",
)
plt.show()
# --- Quantify N100 and P300 --------------------------------------------------
def peak_amplitude_latency(evoked: mne.Evoked, channel: str, tmin: float, tmax: float) -> dict:
"""Return peak amplitude (µV) and latency (ms) within a time window."""
try:
idx = evoked.ch_names.index(channel)
except ValueError:
return {"amplitude_uV": np.nan, "latency_ms": np.nan}
t_mask = (evoked.times >= tmin) & (evoked.times <= tmax)
data = evoked.data[idx, t_mask] * 1e6
times = evoked.times[t_mask] * 1e3
peak_idx = np.argmax(np.abs(data))
return {"amplitude_uV": float(data[peak_idx]), "latency_ms": float(times[peak_idx])}
TARGET_CH = "EEG 059"
for cond, evoked in evokeds.items():
n100 = peak_amplitude_latency(evoked, TARGET_CH, 0.070, 0.150)
p300 = peak_amplitude_latency(evoked, TARGET_CH, 0.250, 0.450)
print(f"\n{cond}")
print(f" N100: {n100['amplitude_uV']:.2f} µV @ {n100['latency_ms']:.0f} ms")
print(f" P300: {p300['amplitude_uV']:.2f} µV @ {p300['latency_ms']:.0f} ms")
# --- Difference wave (deviant minus standard) --------------------------------
# If you have a full oddball dataset with standard/deviant labels:
# diff_wave = mne.combine_evoked([evokeds["deviant"], evokeds["standard"]], weights=[1, -1])
# diff_wave.plot(picks=[TARGET_CH], titles={"eeg": "MMN / Difference Wave"})
# --- Topographic map at P300 peak (300–400 ms) -------------------------------
for cond, evoked in evokeds.items():
fig_topo = evoked.plot_topomap(
times=[0.1, 0.2, 0.3, 0.4],
average=0.05,
show=False,
)
fig_topo.suptitle(f"Topography: {cond}", fontsize=11)
fig_topo.savefig(f"topo_{cond.replace('/', '_')}.png", dpi=120)
Alpha band power (8–13 Hz) reliably increases during eyes-closed rest. This example compares band power across conditions and produces a power spectral density plot.
# ── Example B ─────────────────────────────────────────────────────────────
# Assumes two raw files: resting_eyes_open.edf and resting_eyes_closed.edf
# Replace paths with actual file locations
EYES_OPEN_FILE = os.environ.get("EYES_OPEN_EDF", "resting_eyes_open.edf")
EYES_CLOSED_FILE = os.environ.get("EYES_CLOSED_EDF", "resting_eyes_closed.edf")
OCCIPITAL_CHANNELS = ["O1", "Oz", "O2", "PO3", "PO4", "PO7", "PO8"]
results = {}
psds_dict = {}
spectra_dict = {}
for label, filepath in [("eyes_open", EYES_OPEN_FILE), ("eyes_closed", EYES_CLOSED_FILE)]:
if not os.path.exists(filepath):
print(f"Skipping {label}: file not found ({filepath})")
continue
raw = load_raw_eeg(filepath)
raw = preprocess_raw(raw, l_freq=1.0, h_freq=50.0, notch_freq=50.0)
raw_clean, _ = run_ica_artifact_removal(raw, n_components=0.99)
# Keep only available occipital channels
occ_available = [c for c in OCCIPITAL_CHANNELS if c in raw_clean.ch_names]
if not occ_available:
occ_available = None # Fall back to all EEG
band_df = compute_band_power(raw_clean, picks=occ_available)
band_df["condition"] = label
results[label] = band_df
# Full PSD for plotting
spectrum = raw_clean.compute_psd(method="welch", fmin=1.0, fmax=50.0,
picks=occ_available or "eeg", verbose=False)
spectra_dict[label] = spectrum
# --- Statistical comparison --------------------------------------------------
if len(results) == 2:
from scipy.stats import ttest_rel, wilcoxon
eo = results["eyes_open"]["alpha"].values
ec = results["eyes_closed"]["alpha"].values
if len(eo) == len(ec):
t_stat, p_val = ttest_rel(ec, eo)
print(f"\nAlpha power comparison (occipital channels):")
print(f" Eyes open: {eo.mean():.2f} ± {eo.std():.2f} µV²/Hz")
print(f" Eyes closed: {ec.mean():.2f} ± {ec.std():.2f} µV²/Hz")
print(f" Paired t-test: t={t_stat:.3f}, p={p_val:.4f}")
# --- PSD plot comparison -----------------------------------------------------
if spectra_dict:
fig, ax = plt.subplots(figsize=(10, 6))
colors = {"eyes_open": "steelblue", "eyes_closed": "firebrick"}
for label, spectrum in spectra_dict.items():
psds, freqs = spectrum.get_data(return_freqs=True)
mean_psd = psds.mean(axis=0) * 1e12 # µV²/Hz
se_psd = psds.std(axis=0) / np.sqrt(len(psds)) * 1e12
ax.semilogy(freqs, mean_psd, label=label, color=colors.get(label, "gray"), linewidth=2)
ax.fill_between(
freqs,
mean_psd - se_psd,
mean_psd + se_psd,
alpha=0.2,
color=colors.get(label, "gray"),
)
# Shade alpha band
ax.axvspan(8, 13, alpha=0.12, color="gold", label="Alpha band (8–13 Hz)")
ax.set_xlabel("Frequency (Hz)", fontsize=12)
ax.set_ylabel("Power Spectral Density (µV²/Hz)", fontsize=12)
ax.set_title("Resting-State PSD: Eyes Open vs Eyes Closed (Occipital)", fontsize=13)
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3, which="both")
fig.tight_layout()
plt.savefig("alpha_power_psd.png", dpi=150)
plt.show()
# --- Time-frequency on resting-state (Eyes Closed) -------------------------
# Segment resting state into 2-second pseudo-epochs for TFR
if "eyes_closed" in results:
raw_ec = load_raw_eeg(EYES_CLOSED_FILE)
raw_ec = preprocess_raw(raw_ec, l_freq=1.0, h_freq=50.0)
raw_clean_ec, _ = run_ica_artifact_removal(raw_ec, n_components=0.99)
# Create fixed-length epochs (2 s, no overlap)
epochs_rest = mne.make_fixed_length_epochs(
raw_clean_ec, duration=2.0, preload=True, verbose=False
)
epochs_rest.pick_channels(
[c for c in OCCIPITAL_CHANNELS if c in epochs_rest.ch_names] or epochs_rest.ch_names[:4]
)
freqs_tfr = np.arange(4, 30, 1)
n_cycles_tfr = freqs_tfr / 2.0 # 0.5 cycles per Hz
power, itc = compute_tfr_morlet(
epochs_rest,
freqs=freqs_tfr,
n_cycles=n_cycles_tfr,
return_itc=True,
decim=4,
)
# Plot average TFR
fig_tfr = power.plot(
picks=[0],
baseline=None,
mode="logratio",
title="Resting-State TFR (Eyes Closed)",
show=False,
)
fig_tfr[0].savefig("resting_tfr_eyes_closed.png", dpi=120)
.fif format (raw, epochs, evoked) for lossless round-tripping.epochs.save("sub-01_task-oddball-epo.fif", overwrite=True) and reload with
mne.read_epochs("sub-01_task-oddball-epo.fif").ICA is sensitive to the high-pass filter. Always high-pass at 1 Hz before fitting ICA, even if your final analysis uses a lower cutoff (0.1 Hz for ERP). Apply ICA to the original low-passed raw after fitting on the 1 Hz-filtered version.
Typical peak-to-peak thresholds:
| System | Threshold |
|---|---|
| High-density (128+ ch) | 100 µV |
| Standard (32–64 ch) | 150 µV |
| Clinical/noisy | 200–250 µV |
# Requires FreeSurfer reconstructed subject or fsaverage
subjects_dir = mne.datasets.sample.data_path() + "/subjects"
fwd = mne.read_forward_solution("sample-fwd.fif")
noise_cov = mne.compute_covariance(epochs, tmax=0)
inv = mne.minimum_norm.make_inverse_operator(epochs.info, fwd, noise_cov)
stc = mne.minimum_norm.apply_inverse(evokeds["auditory/left"], inv, lambda2=1.0 / 9.0)
stc.plot(subjects_dir=subjects_dir, hemi="both", initial_time=0.1)