moecog 0.1.0__py3-none-any.whl

moecog/__init__.py

@@ -0,0 +1,6 @@
+"""MOECoG — Mother of All ECoG Benchmarks.
+
+A MOABB-style benchmarking framework for electrocorticographic (ECoG) motor decoding.
+"""
+
+__version__ = "0.1.0"

moecog/analysis/__init__.py

@@ -0,0 +1 @@
+"""Analysis — results storage, statistics, and visualization."""

moecog/datasets/__init__.py

@@ -0,0 +1,8 @@
+"""ECoG dataset loaders."""
+
+from .base import BaseECoGDataset, ElectrodeInfo
+
+__all__ = [
+    "BaseECoGDataset",
+    "ElectrodeInfo",
+]

moecog/datasets/base.py

@@ -0,0 +1,161 @@
+"""Base class for all ECoG datasets."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import numpy as np
+
+
+@dataclass
+class ElectrodeInfo:
+    """Patient-specific electrode metadata.
+
+    Parameters
+    ----------
+    positions : np.ndarray, shape (n_channels, 3)
+        Electrode coordinates (MNI or native space).
+    labels : list of str
+        Channel names.
+    hemisphere : list of str or None
+        Hemisphere per electrode ("L" or "R").
+    lobe : list of str or None
+        Anatomical lobe per electrode.
+    gyrus : list of str or None
+        Gyrus per electrode.
+    brodmann_area : list of int or None
+        Brodmann area per electrode.
+    grid_type : str
+        Electrode array type: "grid", "strip", or "depth".
+    spacing_mm : float
+        Inter-electrode distance in millimeters.
+    """
+
+    positions: np.ndarray
+    labels: list[str]
+    hemisphere: list[str] | None = None
+    lobe: list[str] | None = None
+    gyrus: list[str] | None = None
+    brodmann_area: list[int] | None = None
+    grid_type: str = "grid"
+    spacing_mm: float = 10.0
+
+
+class BaseECoGDataset(ABC):
+    """Base class for all ECoG datasets.
+
+    Every concrete dataset must implement:
+        - ``_get_single_subject_data(subject)``
+        - ``data_path(subject)``
+        - ``get_electrode_info(subject)``
+
+    Parameters
+    ----------
+    subjects : list of int
+        Available subject IDs.
+    sessions_per_subject : int
+        Number of recording sessions per subject.
+    events : dict or None
+        Mapping of event names to integer codes. None for pure regression datasets.
+    code : str
+        Unique dataset identifier string.
+    paradigm : str
+        Paradigm type: "motor_regression", "motor_imagery", or "naturalistic".
+    interval : list of float or None
+        Epoch window [tmin, tmax] in seconds. None for continuous data.
+    sfreq : float
+        Sampling frequency in Hz.
+    doi : str or None
+        DOI of the associated publication.
+    """
+
+    def __init__(
+        self,
+        subjects: list[int],
+        sessions_per_subject: int,
+        events: dict[str, int] | None,
+        code: str,
+        paradigm: str,
+        interval: list[float] | None,
+        sfreq: float,
+        doi: str | None = None,
+    ):
+        self.subject_list = subjects
+        self.n_sessions = sessions_per_subject
+        self.event_id = events
+        self.code = code
+        self.paradigm_type = paradigm
+        self.interval = interval
+        self.sfreq = sfreq
+        self.doi = doi
+
+    def get_data(self, subjects=None):
+        """Load data for one or more subjects.
+
+        Parameters
+        ----------
+        subjects : list of int or None
+            Subject IDs to load. If None, loads all subjects.
+
+        Returns
+        -------
+        dict
+            Nested dict: ``{subject: {session: {run: mne.io.Raw}}}``.
+        """
+        subjects = subjects or self.subject_list
+        data = {}
+        for subject in subjects:
+            data[subject] = self._get_single_subject_data(subject)
+        return data
+
+    @abstractmethod
+    def _get_single_subject_data(self, subject):
+        """Load all sessions and runs for a single subject.
+
+        Parameters
+        ----------
+        subject : int
+            Subject identifier.
+
+        Returns
+        -------
+        dict
+            ``{session_id: {run_id: mne.io.Raw}}``.
+        """
+
+    @abstractmethod
+    def data_path(self, subject):
+        """Return local file paths for a subject's data, downloading if needed.
+
+        Parameters
+        ----------
+        subject : int
+            Subject identifier.
+
+        Returns
+        -------
+        list of Path
+            Local paths to the data files.
+        """
+
+    @abstractmethod
+    def get_electrode_info(self, subject):
+        """Return electrode metadata for a subject.
+
+        Parameters
+        ----------
+        subject : int
+            Subject identifier.
+
+        Returns
+        -------
+        ElectrodeInfo
+            Electrode positions and anatomical labels.
+        """
+
+    def __repr__(self):
+        return (
+            f"{self.__class__.__name__}(code={self.code!r}, "
+            f"subjects={len(self.subject_list)}, "
+            f"sessions={self.n_sessions})"
+        )

moecog/evaluations/__init__.py

@@ -0,0 +1,7 @@
+"""Evaluation strategies for ECoG benchmarking."""
+
+from .base import BaseEvaluation
+
+__all__ = [
+    "BaseEvaluation",
+]

moecog/evaluations/base.py

@@ -0,0 +1,111 @@
+"""Base evaluation class."""
+
+import time
+from abc import ABC, abstractmethod
+
+import numpy as np
+import pandas as pd
+from sklearn.base import clone
+
+
+class BaseEvaluation(ABC):
+    """Base class for all evaluation strategies.
+
+    Parameters
+    ----------
+    paradigm : BaseParadigm
+        Paradigm instance defining the task.
+    datasets : list of BaseECoGDataset
+        Datasets to evaluate on (filtered for paradigm compatibility).
+    n_splits : int
+        Number of cross-validation folds.
+    random_state : int
+        Random seed for reproducibility.
+    """
+
+    def __init__(self, paradigm, datasets, n_splits=5, random_state=42):
+        self.paradigm = paradigm
+        self.datasets = [d for d in datasets if paradigm.is_valid(d)]
+        self.n_splits = n_splits
+        self.random_state = random_state
+
+    def process(self, pipelines):
+        """Run all pipelines on all compatible datasets.
+
+        Parameters
+        ----------
+        pipelines : dict of str to sklearn estimator
+            Named pipelines to evaluate.
+
+        Returns
+        -------
+        pd.DataFrame
+            Results with columns: dataset, subject, session, pipeline,
+            score, metric, time, n_samples, n_channels, fold.
+        """
+        all_results = []
+        for dataset in self.datasets:
+            X, y, metadata = self.paradigm.get_data(dataset)
+            results = self._evaluate(dataset, X, y, metadata, pipelines)
+            all_results.extend(results)
+        return pd.DataFrame(all_results)
+
+    @abstractmethod
+    def _evaluate(self, dataset, X, y, metadata, pipelines):
+        """Implement the cross-validation strategy.
+
+        Returns
+        -------
+        list of dict
+            One dict per (pipeline, fold, subject) combination.
+        """
+
+    def _score_pipeline(self, pipeline, X_train, y_train, X_test, y_test):
+        """Fit a pipeline and compute scores."""
+        t0 = time.time()
+        clf = clone(pipeline)
+
+        if X_train.ndim == 3:
+            try:
+                clf.fit(X_train, y_train)
+                y_pred = clf.predict(X_test)
+            except ValueError:
+                X_tr = X_train.reshape(X_train.shape[0], -1)
+                X_te = X_test.reshape(X_test.shape[0], -1)
+                clf.fit(X_tr, y_train)
+                y_pred = clf.predict(X_te)
+        else:
+            clf.fit(X_train, y_train)
+            y_pred = clf.predict(X_test)
+
+        duration = time.time() - t0
+
+        scoring = self.paradigm.scoring()
+        if isinstance(scoring, str):
+            scores = {scoring: _compute_metric(scoring, y_test, y_pred)}
+        else:
+            scores = {
+                name: _compute_metric(name, y_test, y_pred) for name in scoring
+            }
+
+        return {"scores": scores, "time": duration}
+
+
+def _compute_metric(metric_name, y_true, y_pred):
+    """Compute a single evaluation metric."""
+    from scipy.stats import pearsonr
+    from sklearn.metrics import accuracy_score, cohen_kappa_score, r2_score
+
+    if metric_name == "pearson_r":
+        if y_true.ndim == 1:
+            return pearsonr(y_true, y_pred)[0]
+        rs = [pearsonr(y_true[:, i], y_pred[:, i])[0] for i in range(y_true.shape[1])]
+        return float(np.mean(rs))
+    elif metric_name == "r2":
+        return r2_score(y_true, y_pred, multioutput="uniform_average")
+    elif metric_name == "accuracy":
+        return accuracy_score(y_true, y_pred)
+    elif metric_name == "kappa":
+        return cohen_kappa_score(y_true, y_pred)
+    else:
+        raise ValueError(f"Unknown metric: {metric_name}")

moecog/paradigms/__init__.py

@@ -0,0 +1,9 @@
+"""ECoG paradigms — transform raw data into (X, y, metadata)."""
+
+from .base import BaseClassificationParadigm, BaseParadigm, BaseRegressionParadigm
+
+__all__ = [
+    "BaseParadigm",
+    "BaseClassificationParadigm",
+    "BaseRegressionParadigm",
+]

moecog/paradigms/base.py

@@ -0,0 +1,209 @@
+"""Base paradigm classes for classification and regression tasks."""
+
+from abc import ABC, abstractmethod
+
+import mne
+import numpy as np
+import pandas as pd
+
+
+class BaseParadigm(ABC):
+    """Base class for all paradigms.
+
+    Transforms raw ECoG data from a dataset into ``(X, y, metadata)`` arrays
+    ready for scikit-learn pipelines.
+
+    Parameters
+    ----------
+    fmin : float
+        Lower bandpass frequency in Hz.
+    fmax : float
+        Upper bandpass frequency in Hz.
+    resample : float or None
+        Target sampling rate in Hz. None keeps the original rate.
+    channels : list of str or None
+        Channel names to select. None uses all ECoG channels.
+    """
+
+    def __init__(
+        self,
+        fmin: float = 0.5,
+        fmax: float = 200.0,
+        resample: float | None = None,
+        channels: list[str] | None = None,
+    ):
+        self.fmin = fmin
+        self.fmax = fmax
+        self.resample = resample
+        self.channels = channels
+
+    @abstractmethod
+    def get_data(self, dataset, subjects=None):
+        """Extract (X, y, metadata) from a dataset.
+
+        Returns
+        -------
+        X : np.ndarray
+        y : np.ndarray
+        metadata : pd.DataFrame
+        """
+
+    @abstractmethod
+    def is_valid(self, dataset) -> bool:
+        """Check if a dataset is compatible with this paradigm."""
+
+    @abstractmethod
+    def scoring(self):
+        """Return scoring metric name(s)."""
+
+    @property
+    @abstractmethod
+    def datasets(self) -> list:
+        """Return list of compatible dataset classes."""
+
+    def _preprocess_raw(self, raw):
+        """Apply bandpass filter, channel selection, and resampling."""
+        raw = raw.copy()
+        raw.filter(self.fmin, self.fmax, verbose=False)
+        if self.channels:
+            raw.pick_channels(self.channels)
+        if self.resample:
+            raw.resample(self.resample, verbose=False)
+        return raw
+
+
+class BaseClassificationParadigm(BaseParadigm):
+    """Base paradigm for epoched classification tasks.
+
+    Parameters
+    ----------
+    tmin : float
+        Epoch start time relative to event onset (seconds).
+    tmax : float or None
+        Epoch end time relative to event onset (seconds).
+    baseline : tuple or None
+        Baseline correction window.
+    """
+
+    def __init__(self, tmin=0.0, tmax=None, baseline=None, **kwargs):
+        super().__init__(**kwargs)
+        self.tmin = tmin
+        self.tmax = tmax
+        self.baseline = baseline
+
+    @abstractmethod
+    def used_events(self, dataset):
+        """Return the event dict this paradigm uses from the dataset."""
+
+    def get_data(self, dataset, subjects=None):
+        subjects = subjects or dataset.subject_list
+        all_X, all_y, all_meta = [], [], []
+
+        for subject in subjects:
+            sub_data = dataset.get_data(subjects=[subject])
+            for session_id, runs in sub_data[subject].items():
+                for run_id, raw in runs.items():
+                    raw = self._preprocess_raw(raw)
+                    events, _ = mne.events_from_annotations(raw, verbose=False)
+                    used = self.used_events(dataset)
+                    tmax = self.tmax if self.tmax is not None else dataset.interval[1]
+                    epochs = mne.Epochs(
+                        raw,
+                        events,
+                        event_id=used,
+                        tmin=self.tmin,
+                        tmax=tmax,
+                        baseline=self.baseline,
+                        preload=True,
+                        verbose=False,
+                    )
+                    X = epochs.get_data(copy=False)
+                    y = np.array(
+                        [
+                            list(used.keys())[list(used.values()).index(e)]
+                            for e in epochs.events[:, 2]
+                        ]
+                    )
+                    meta = pd.DataFrame(
+                        {"subject": subject, "session": session_id, "run": run_id},
+                        index=range(len(y)),
+                    )
+                    all_X.append(X)
+                    all_y.append(y)
+                    all_meta.append(meta)
+
+        return (
+            np.concatenate(all_X),
+            np.concatenate(all_y),
+            pd.concat(all_meta).reset_index(drop=True),
+        )
+
+
+class BaseRegressionParadigm(BaseParadigm):
+    """Base paradigm for continuous regression tasks.
+
+    Uses causal windowing: target ``y[i]`` is the value at the **end** of
+    window ``i``, ensuring the model only sees past neural data.
+
+    Parameters
+    ----------
+    window_size : float
+        Window length in seconds.
+    window_stride : float
+        Stride between windows in seconds.
+    """
+
+    def __init__(self, window_size=0.5, window_stride=0.05, **kwargs):
+        super().__init__(**kwargs)
+        self.window_size = window_size
+        self.window_stride = window_stride
+
+    @abstractmethod
+    def _extract_targets(self, raw, dataset):
+        """Extract continuous target signals from a Raw object.
+
+        Returns
+        -------
+        np.ndarray, shape (n_samples, n_targets)
+        """
+
+    def get_data(self, dataset, subjects=None):
+        subjects = subjects or dataset.subject_list
+        all_X, all_y, all_meta = [], [], []
+
+        for subject in subjects:
+            sub_data = dataset.get_data(subjects=[subject])
+            for session_id, runs in sub_data[subject].items():
+                for run_id, raw in runs.items():
+                    raw = self._preprocess_raw(raw)
+                    targets = self._extract_targets(raw, dataset)
+
+                    sfreq = raw.info["sfreq"]
+                    data = raw.pick(picks="ecog", exclude=[]).get_data()
+                    win_samples = int(self.window_size * sfreq)
+                    stride_samples = int(self.window_stride * sfreq)
+
+                    n_windows = (data.shape[1] - win_samples) // stride_samples + 1
+                    X = np.zeros((n_windows, data.shape[0], win_samples))
+                    y = np.zeros((n_windows, targets.shape[1]))
+
+                    for i in range(n_windows):
+                        start = i * stride_samples
+                        end = start + win_samples
+                        X[i] = data[:, start:end]
+                        # Causal: target at end of window
+                        y[i] = targets[min(end, targets.shape[0] - 1)]
+
+                    meta = pd.DataFrame(
+                        {"subject": subject, "session": session_id, "run": run_id},
+                        index=range(n_windows),
+                    )
+                    all_X.append(X)
+                    all_y.append(y)
+                    all_meta.append(meta)
+
+        return (
+            np.concatenate(all_X),
+            np.concatenate(all_y),
+            pd.concat(all_meta).reset_index(drop=True),
+        )

moecog/pipelines/__init__.py

@@ -0,0 +1 @@
+"""Pipelines — feature extractors and decoders for ECoG."""

moecog/pipelines/decoders/__init__.py

@@ -0,0 +1 @@
+"""Neural network decoders for ECoG signals."""

moecog/pipelines/features/__init__.py

@@ -0,0 +1 @@
+"""Feature extraction transformers for ECoG signals."""

moecog/utils/__init__.py

@@ -0,0 +1 @@
+"""Utilities — electrode mapping, signal processing helpers."""

moecog-0.1.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: moecog
+Version: 0.1.0
+Summary: Mother of All ECoG Benchmarks — MOABB-style benchmarking for ECoG motor decoding
+Author-email: Yifan Yu <yifanyu97@gmail.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/epyifany/MOECoG
+Project-URL: Repository, https://github.com/epyifany/MOECoG
+Project-URL: Issues, https://github.com/epyifany/MOECoG/issues
+Keywords: ECoG,electrocorticography,BCI,brain-computer interface,motor decoding,benchmark,neuroscience,neural decoding
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mne>=1.5
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: pandas>=2.0
+Requires-Dist: h5py>=3.8
+Requires-Dist: pooch>=1.7
+Requires-Dist: tqdm>=4.65
+Provides-Extra: deep
+Requires-Dist: torch>=2.0; extra == "deep"
+Requires-Dist: braindecode>=0.8; extra == "deep"
+Provides-Extra: nwb
+Requires-Dist: pynwb>=2.5; extra == "nwb"
+Requires-Dist: dandi>=0.55; extra == "nwb"
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.7; extra == "viz"
+Requires-Dist: seaborn>=0.12; extra == "viz"
+Provides-Extra: anatomy
+Requires-Dist: nilearn>=0.10; extra == "anatomy"
+Requires-Dist: nibabel>=5.0; extra == "anatomy"
+Provides-Extra: dev
+Requires-Dist: moecog[anatomy,deep,nwb,viz]; extra == "dev"
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Provides-Extra: all
+Requires-Dist: moecog[anatomy,deep,nwb,viz]; extra == "all"
+Dynamic: license-file
+
+# MOECoG — Mother of All ECoG Benchmarks
+
+A MOABB-style benchmarking framework for electrocorticographic (ECoG) motor decoding.
+
+> *"ECoG isn't just the future — it's the testable present."*
+
+## Vision
+
+[MOABB](https://github.com/NeuroTechX/moabb) transformed EEG-BCI research by making algorithm comparison reproducible and fair. **MOECoG does the same for ECoG motor decoding** — the signal modality at the critical intersection of clinical viability (long-term stability, lower surgical risk) and high-performance neural control (high-gamma access, mm-scale spatial resolution).
+
+This project will be successful when we read in an abstract:
+
+> *"...the proposed method obtained a correlation of 0.82 on MOECoG, outperforming the state of the art by 12%..."*
+
+## Why ECoG Needs Its Own Benchmark
+
+| Property | EEG (MOABB) | ECoG (MOECoG) |
+|---|---|---|
+| Signal type | Scalp potentials | Cortical surface potentials |
+| Key features | mu/beta ERD/ERS | High-gamma broadband (>70 Hz) + beta suppression |
+| Spatial resolution | ~cm | ~mm |
+| Electrode geometry | Standard montages (10-20) | Patient-specific grids/strips |
+| Primary tasks | Classification (L/R imagery) | Both classification AND continuous regression |
+| Cross-subject | Standard channel alignment | Requires anatomical registration |
+| Noise profile | EMG, EOG artifacts | Epileptiform activity, referencing |
+
+MOABB's paradigm/dataset/evaluation/pipeline abstraction is brilliant — but its assumptions (fixed channel montages, epoched classification, standard frequency bands) break down for ECoG.
+
+## Architecture
+
+MOECoG follows MOABB's 4-concept design, adapted for ECoG:
+
+```
++--------------+    +---------------+    +---------------+    +---------------+
+|   Dataset    |--->|   Paradigm    |--->|  Evaluation   |--->|   Pipeline    |
+|              |    |               |    |               |    |               |
+| Raw ECoG +   |    | Motor Imagery |    | WithinSubject |    | Feature ext.  |
+| electrode    |    | Finger Flex   |    | CrossSession  |    | + Classifier  |
+| positions +  |    | Arm Reach     |    | Transfer      |    | or Regressor  |
+| anatomy      |    | Grasp Type    |    |               |    |               |
++--------------+    +---------------+    +---------------+    +---------------+
+```
+
+### Key Differences from MOABB
+
+- **Dual-task paradigms:** Classification (which finger?) AND regression (finger trajectory)
+- **Anatomical electrode registration:** Patient-specific grids mapped to MNI/FreeSurfer atlas
+- **Broadband feature extraction:** High-gamma (70-150 Hz), beta (13-30 Hz), phase-amplitude coupling
+- **Continuous decoding metrics:** Correlation coefficient (r), R-squared, normalized MSE — not just accuracy
+- **Naturalistic movement support:** Not just cued trials but free/spontaneous movements (AJILE12)
+
+## Included Datasets
+
+### Tier 1: Core Benchmark
+
+Motor-specific, public, well-documented.
+
+| ID | Dataset | Source | Subjects | Task | Channels | Modality |
+|---|---|---|---|---|---|---|
+| MillerFingerFlex | BCI Competition IV Dataset 4 | Miller & Schalk | 3 | Individual finger flexion (5-class regression) | 48-64 | ECoG grid |
+| MillerLibrary | Stanford/Mayo ECoG Library | Miller 2019, *Nature Human Behaviour* | 34 | 16 experiments (motor, sensory, language, visual) | Varies | ECoG grid |
+| AJILE12 | Annotated Joints in Long-term ECoG | Peterson et al. 2022, *Scientific Data* | 12 | Naturalistic wrist movements | >=64 | ECoG grid |
+
+### Tier 2: Extended Benchmark
+
+| ID | Dataset | Source | Subjects | Task |
+|---|---|---|---|---|
+| BCITetraplegia | BCI and Tetraplegia (WIMAGINE) | Benabid/Costecalde et al. | 1 (chronic) | 4-class motor imagery, 2D cursor |
+| GraspECoG | Natural grasp types | Various (Pistohl, Bleichner) | Varies | Grasp classification |
+| MoveAgain | Blackrock/BrainGate ECoG subsets | If released publicly | Varies | Arm/hand movement |
+
+### Tier 3: Cross-Modality Comparison
+
+| ID | Dataset | Why included |
+|---|---|---|
+| MOABB_MI | MOABB motor imagery EEG datasets | Direct EEG vs ECoG comparison on matched paradigms |
+
+## Paradigms
+
+### FingerFlexionRegression
+
+- **Task:** Predict continuous finger flexion trajectories from ECoG
+- **Metrics:** Pearson r, R-squared, NRMSE per finger
+- **Datasets:** MillerFingerFlex, MillerLibrary (motor subset)
+- **Baseline:** BCI Competition IV Dataset 4 leaderboard
+
+### MotorImageryClassification
+
+- **Task:** Classify imagined/attempted movements (L/R hand, feet, tongue, etc.)
+- **Metrics:** Accuracy, ROC-AUC, Cohen's kappa
+- **Datasets:** MillerLibrary (motor imagery subset), BCITetraplegia
+
+### NaturalisticReachDecoding
+
+- **Task:** Decode wrist movement onset and trajectory from unconstrained behavior
+- **Metrics:** Event detection F1, trajectory r, latency
+- **Datasets:** AJILE12
+
+### GraspClassification
+
+- **Task:** Classify grasp types or hand gestures from sensorimotor ECoG
+- **Metrics:** Accuracy, confusion matrix analysis
+- **Datasets:** GraspECoG, MillerLibrary (gesture subset)
+
+## Evaluation Strategies
+
+| Strategy | Description | Use Case |
+|---|---|---|
+| WithinSubjectCV | K-fold within single subject | Standard single-patient decoding |
+| CrossSessionEval | Train on session A, test on session B | Stability / recalibration assessment |
+| CrossSubjectTransfer | Leave-one-subject-out (with atlas projection) | Generalization / zero-shot transfer |
+| TemporalStabilityEval | Chronological split (early to late) | Long-term signal stability |
+
+## Baseline Pipelines
+
+### Feature Extraction
+
+- **LogBandPower** — Log power in canonical bands (mu, beta, low-gamma, high-gamma)
+- **BroadbandChange** — Miller's broadband spectral change method
+- **PAC** — Phase-amplitude coupling (theta/gamma, beta/high-gamma)
+- **CSP_ECoG** — Common Spatial Patterns adapted for patient-specific grids
+- **TimeFrequency** — Continuous wavelet / multitaper spectrograms
+
+### Decoders
+
+- **LDA / SVM / LogisticRegression** — Classical classifiers
+- **Ridge / Kalman** — Linear regressors for trajectory decoding
+- **ECoGNet** — Lightweight CNN for ECoG (braindecode-compatible)
+- **FingerFlex** — Convolutional encoder-decoder (Lomtev et al.)
+- **HTNet** — Transfer learning across subjects via Hilbert transform
+
+## Quick Start
+
+```python
+import moecog
+from moecog.datasets import MillerFingerFlex
+from moecog.paradigms import FingerFlexionRegression
+from moecog.evaluations import WithinSubjectCV
+from moecog.pipelines.features import LogBandPower
+from sklearn.linear_model import Ridge
+from sklearn.pipeline import make_pipeline
+
+# Define pipeline
+pipelines = {
+    "LogBandPower+Ridge": make_pipeline(LogBandPower(), Ridge(alpha=1.0))
+}
+
+# Load data
+dataset = MillerFingerFlex()
+paradigm = FingerFlexionRegression(fmin=1, fmax=150)
+evaluation = WithinSubjectCV(paradigm=paradigm, datasets=[dataset], n_splits=5)
+
+# Run benchmark
+results = evaluation.process(pipelines)
+print(results.groupby("pipeline")["score"].mean())
+```
+
+## Installation
+
+```bash
+pip install moecog
+```
+
+Or for development:
+
+```bash
+git clone https://github.com/epyifany/MOECoG.git
+cd MOECoG
+pip install -e ".[dev]"
+```
+
+### Dependencies
+
+**Core:**
+- `mne >= 1.5` — ECoG signal handling, coordinate transforms
+- `numpy`, `scipy`, `scikit-learn` — Core ML
+- `pandas` — Results management
+- `h5py` — Persistent results storage
+- `pooch` — Robust data downloading
+
+**Optional:**
+- `torch`, `braindecode` — Deep learning baselines (`pip install moecog[deep]`)
+- `pynwb`, `dandi` — NWB data access for AJILE12 (`pip install moecog[nwb]`)
+- `nilearn`, `nibabel` — Anatomical registration (`pip install moecog[anatomy]`)
+- `matplotlib`, `seaborn` — Visualization (`pip install moecog[viz]`)
+
+## Citation
+
+If you use MOECoG in your research, please cite:
+
+```bibtex
+@software{moecog2025,
+  title = {MOECoG: Mother of All ECoG Benchmarks},
+  author = {Yu, Yifan},
+  year = {2025},
+  url = {https://github.com/epyifany/MOECoG}
+}
+```
+
+And the foundational datasets:
+
+- Miller, K.J. "A library of human electrocorticographic data and analyses." *Nature Human Behaviour* 3(11), 1225-1235 (2019).
+- Peterson, S.M. et al. "AJILE12: Long-term naturalistic human intracranial neural recordings and pose." *Scientific Data* 9, 184 (2022).
+- Schalk, G. et al. BCI Competition IV Dataset 4.
+
+## License
+
+BSD-3-Clause (matching MOABB)

moecog-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+moecog/__init__.py,sha256=e5F7QRudYbcoibqVlP46le-BOnHcqjH8inBYduFXtIs,159
+moecog/analysis/__init__.py,sha256=ExR9A1yjIdZMZkpF7R6nvDNJEIBy7l1oLy9M_rqZc7w,67
+moecog/datasets/__init__.py,sha256=66_Y1EAyZq95-PqzxgnxQ8xhXVgg1v3ClMp5aRUuBZo,137
+moecog/datasets/base.py,sha256=krZ64AwYqH8hSObZJXuyKu9WK8NO146r5RojyhCjT3I,4328
+moecog/evaluations/__init__.py,sha256=iZOCMX5TwwM1Ufub-VXTa7pOK42fZiRJ49_NXdoF9bc,122
+moecog/evaluations/base.py,sha256=t2pjnQC6tGwv3180WCW6CEl2oD4QN6Q9xl2QVgteyf4,3584
+moecog/paradigms/__init__.py,sha256=prOaV6pBOm-TxmCgZHi95vBTGRWRi-xEb03ywQk65XI,250
+moecog/paradigms/base.py,sha256=9POMm55YuVBOdAFc5am23Bt_3OEw_hsnzHX4SUizEiI,6907
+moecog/pipelines/__init__.py,sha256=pD1TEeHjiqpM7W54OTHwfhnH1prFokliRpeGjg8mCs8,62
+moecog/pipelines/decoders/__init__.py,sha256=7x__BdnPIPSCUVmAmsT39pzQr139zqu2pAJS_8sngHo,48
+moecog/pipelines/features/__init__.py,sha256=oskX5GdeEWLQX5f9nOq_tdK98QbUNMBDNSUeqeuXTkY,56
+moecog/utils/__init__.py,sha256=6qo244StRvNH_Rc8rUqLPGzU7FZc5hkITntUkC27xNc,66
+moecog-0.1.0.dist-info/licenses/LICENSE,sha256=tjJri2nMHvBODozIWCOPxUaIkCMC-nEAAn-FKy1YQpQ,1495
+moecog-0.1.0.dist-info/METADATA,sha256=QC6KtNGzBTJ_-to2a5sRGcyKQHDIL7Sqnk639wkVvYg,10446
+moecog-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+moecog-0.1.0.dist-info/top_level.txt,sha256=vh-OEq_cEuJ4LlBwz8NC_PNJprGmFqFi5c3VVtdqtaM,7
+moecog-0.1.0.dist-info/RECORD,,

moecog-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

moecog-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Yifan Yu
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

moecog-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+moecog