blockperm 0.1.0__tar.gz

blockperm-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dongjin Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

blockperm-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: blockperm
+Version: 0.1.0
+Summary: Block permutation test for cross-validated decoding when labels follow recording blocks
+Author: Dongjin Choi
+License-Expression: MIT
+Project-URL: Repository, https://github.com/jinchoi7651507/block-permutation-decoding
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scikit-learn>=1.4
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# blockperm: a block permutation test for cross-validated decoding
+
+`block_permutation_test_score` tests a cross-validated decoding score when the labels follow recording blocks (for example conditions presented in blocks of consecutive trials) and training and test trials may come from the same blocks. It has the call pattern of scikit-learn's `permutation_test_score`:
+
+```python
+from blockperm import block_permutation_test_score
+
+score, null_scores, p = block_permutation_test_score(
+    pipeline, X, y, blocks=block_id, cv=KFold(5, shuffle=True, random_state=0), n_permutations=1000, random_state=0)
+```
+
+## What it does
+- Each permutation permutes the labels of whole blocks between blocks, so the labels of training and test trials move together and every block keeps its trials.
+- The whole cross-validation is rerun for every permutation, including every step fitted to the labels. Put scaling, feature or neuron selection and the model in one scikit-learn `Pipeline`.
+- `strata` restricts the permutation to blocks within the same stratum (for example within a run or a session).
+- `draw` replaces the permutation with a user-given generator of block-label vectors, for example pseudosessions drawn from the task's own block generator.
+- With few blocks the function enumerates every distinct arrangement (`exact="auto"`) and warns about the smallest attainable p value. With two blocks per class there are six arrangements, but for a two-class decoder an arrangement and its class swap give the same score, so p cannot fall below about one in three.
+
+## When it is valid
+- The enumerated null is exact, and the sampled p value valid, when the observed assignment was drawn uniformly from the set the function permutes over: all arrangements of the block labels, or all arrangements within `strata` if the design randomized within strata (for example within runs). Permuting across a unit the design did not randomize over can reject too often. For a constrained randomization (counterbalancing, limits per run), pass the design's own generator as `draw`.
+- With a fixed block order, the test assumes that blocks are exchangeable under the null. Slow drift that follows the order can break this assumption, and then the test can reject or be conservative. A design with random block order, or several blocks per condition in random order, avoids the problem.
+- With `GroupKFold` and blocks of equal size, the block-to-fold map depends on the tie order of `numpy.argsort`, which differs between platforms (arm64 and x86 gave different maps for 24 blocks with the same versions). For a result that reruns identically elsewhere, pass explicit folds (a list of train/test index pairs) or a shuffled `GroupKFold` with a seed (scikit-learn 1.6 or later), and record the folds.
+
+## Why not the defaults
+In the analyses this function accompanies, three rules that toolboxes run were tested on labels with no information, assigned to recording blocks, with training and test trials sharing blocks:
+- trial-level permutation with the cross-validation rerun (scikit-learn `permutation_test_score`, MVPA-Light);
+- trial-level permutation within runs (the CoSMoMVPA tutorial rule);
+- permutation of training labels only, with test labels kept (the PyMVPA tutorial rule).
+
+All three rejected far more often than 5%. Permuting block labels and rerunning the whole cross-validation stayed near 5% in random block designs. With a fixed block order the result depends on the data. In the simulated fixed orders the test was conservative (0–2.4% with shuffled 5-fold). In resting EEG with fixed orders aligned with slow drift it rejected often (first half against second half in most recordings, a pairs-of-blocks order in 29%), and it stayed near 5% for an order orthogonal to a linear trend. There the blocks were not exchangeable (label = time; see "When it is valid"). With labels that vary trial by trial, the first two rules stayed near 5%, and the training-label rule was somewhat above it (10–12%); the large excess arises when labels follow blocks. `examples/fake_block_labels.py` shows the effect on a synthetic drifting recording.
+
+## One-line changes per tool
+- **scikit-learn:** call `block_permutation_test_score` with `blocks=`. Passing `groups=` to `permutation_test_score` restricts the shuffle to within groups; with labels constant within blocks, every permutation then returns the observed labels.
+- **CoSMoMVPA / PyMVPA:** permute chunk-level labels across chunks (one label per chunk, all trials of a chunk together) within the unit the design randomized over (within runs if blocks were randomized within runs; `strata=` here), and rerun the cross-validation.
+- **PyMVPA training-label permutation:** permute the labels of all trials, training and test, block by block.
+
+## Install and test
+Python 3.12 with numpy, scipy and scikit-learn (tested with numpy 2.5.4, scipy 1.18.1, scikit-learn 1.7.2); tested on macOS (arm64). No special hardware is needed; one CPU core is enough.
+
+```sh
+pip install blockperm           # from PyPI; or, in this folder, pip install ".[test]" (with pytest), or copy blockperm.py into a project
+python -m pytest tests          # a few minutes on one core; the warnings it prints are expected
+python examples/fake_block_labels.py
+```
+
+On a laptop (Apple arm64, 2026-11-10) the install took about 15 s with a network connection, the tests about 1.5 min and the example about 1.5 min. In this folder alone the tests end with "8 passed, 4 skipped" (the equivalence tests need the reference file named below); inside the paper's repository they end with "12 passed". The example prints:
+
+```
+labels with no information, 40 recordings, p < 0.05:
+  permutation_test_score (trial labels permuted): 14 (35%)
+  block_permutation_test_score (block labels permuted): 1 (2%)
+```
+
+The test `test_equivalence_with_reference` checks that, with `exact=False`, the same `random_state` Generator and the same folds, this function returns the same observed score, null scores and p value (except that it returns no null when the observed score is undefined) as the reference implementation used in the analyses (`analyses/step2-comparison/code/sim.py` in the paper's repository; another location can be given with `REFERENCE_SIM_DIR`), for shuffled 5-fold, re-split stratified 5-fold, GroupKFold by block and a user `draw`; it is skipped when that file is not present. With the default `exact="auto"`, designs with no more arrangements than `n_permutations` are enumerated instead (the null then has one score per arrangement).
+
+## Tutorial, MATLAB and Octave
+- `docs/TUTORIAL.md`: a step-by-step guide (folds, strata, pseudosessions, few blocks, fixed block orders, checking a pipeline with labels that carry no information).
+- `matlab/`: a MATLAB and Octave port, `block_permutation_test.m`, which takes a function returning the cross-validated score for a label vector. This Python function is the reference; the port is checked against it in `matlab/crosscheck/` (`matlab/README.md`).
+- On PyPI: `pip install blockperm` (version 0.1.0, the version used in the paper).
+
+## Not included
+No `n_jobs` and no fit parameters (unlike `permutation_test_score`); the permutations run one after another. License: MIT (`LICENSE`).

blockperm-0.1.0/README.md

@@ -0,0 +1,62 @@
+# blockperm: a block permutation test for cross-validated decoding
+
+`block_permutation_test_score` tests a cross-validated decoding score when the labels follow recording blocks (for example conditions presented in blocks of consecutive trials) and training and test trials may come from the same blocks. It has the call pattern of scikit-learn's `permutation_test_score`:
+
+```python
+from blockperm import block_permutation_test_score
+
+score, null_scores, p = block_permutation_test_score(
+    pipeline, X, y, blocks=block_id, cv=KFold(5, shuffle=True, random_state=0), n_permutations=1000, random_state=0)
+```
+
+## What it does
+- Each permutation permutes the labels of whole blocks between blocks, so the labels of training and test trials move together and every block keeps its trials.
+- The whole cross-validation is rerun for every permutation, including every step fitted to the labels. Put scaling, feature or neuron selection and the model in one scikit-learn `Pipeline`.
+- `strata` restricts the permutation to blocks within the same stratum (for example within a run or a session).
+- `draw` replaces the permutation with a user-given generator of block-label vectors, for example pseudosessions drawn from the task's own block generator.
+- With few blocks the function enumerates every distinct arrangement (`exact="auto"`) and warns about the smallest attainable p value. With two blocks per class there are six arrangements, but for a two-class decoder an arrangement and its class swap give the same score, so p cannot fall below about one in three.
+
+## When it is valid
+- The enumerated null is exact, and the sampled p value valid, when the observed assignment was drawn uniformly from the set the function permutes over: all arrangements of the block labels, or all arrangements within `strata` if the design randomized within strata (for example within runs). Permuting across a unit the design did not randomize over can reject too often. For a constrained randomization (counterbalancing, limits per run), pass the design's own generator as `draw`.
+- With a fixed block order, the test assumes that blocks are exchangeable under the null. Slow drift that follows the order can break this assumption, and then the test can reject or be conservative. A design with random block order, or several blocks per condition in random order, avoids the problem.
+- With `GroupKFold` and blocks of equal size, the block-to-fold map depends on the tie order of `numpy.argsort`, which differs between platforms (arm64 and x86 gave different maps for 24 blocks with the same versions). For a result that reruns identically elsewhere, pass explicit folds (a list of train/test index pairs) or a shuffled `GroupKFold` with a seed (scikit-learn 1.6 or later), and record the folds.
+
+## Why not the defaults
+In the analyses this function accompanies, three rules that toolboxes run were tested on labels with no information, assigned to recording blocks, with training and test trials sharing blocks:
+- trial-level permutation with the cross-validation rerun (scikit-learn `permutation_test_score`, MVPA-Light);
+- trial-level permutation within runs (the CoSMoMVPA tutorial rule);
+- permutation of training labels only, with test labels kept (the PyMVPA tutorial rule).
+
+All three rejected far more often than 5%. Permuting block labels and rerunning the whole cross-validation stayed near 5% in random block designs. With a fixed block order the result depends on the data. In the simulated fixed orders the test was conservative (0–2.4% with shuffled 5-fold). In resting EEG with fixed orders aligned with slow drift it rejected often (first half against second half in most recordings, a pairs-of-blocks order in 29%), and it stayed near 5% for an order orthogonal to a linear trend. There the blocks were not exchangeable (label = time; see "When it is valid"). With labels that vary trial by trial, the first two rules stayed near 5%, and the training-label rule was somewhat above it (10–12%); the large excess arises when labels follow blocks. `examples/fake_block_labels.py` shows the effect on a synthetic drifting recording.
+
+## One-line changes per tool
+- **scikit-learn:** call `block_permutation_test_score` with `blocks=`. Passing `groups=` to `permutation_test_score` restricts the shuffle to within groups; with labels constant within blocks, every permutation then returns the observed labels.
+- **CoSMoMVPA / PyMVPA:** permute chunk-level labels across chunks (one label per chunk, all trials of a chunk together) within the unit the design randomized over (within runs if blocks were randomized within runs; `strata=` here), and rerun the cross-validation.
+- **PyMVPA training-label permutation:** permute the labels of all trials, training and test, block by block.
+
+## Install and test
+Python 3.12 with numpy, scipy and scikit-learn (tested with numpy 2.5.4, scipy 1.18.1, scikit-learn 1.7.2); tested on macOS (arm64). No special hardware is needed; one CPU core is enough.
+
+```sh
+pip install blockperm           # from PyPI; or, in this folder, pip install ".[test]" (with pytest), or copy blockperm.py into a project
+python -m pytest tests          # a few minutes on one core; the warnings it prints are expected
+python examples/fake_block_labels.py
+```
+
+On a laptop (Apple arm64, 2026-11-10) the install took about 15 s with a network connection, the tests about 1.5 min and the example about 1.5 min. In this folder alone the tests end with "8 passed, 4 skipped" (the equivalence tests need the reference file named below); inside the paper's repository they end with "12 passed". The example prints:
+
+```
+labels with no information, 40 recordings, p < 0.05:
+  permutation_test_score (trial labels permuted): 14 (35%)
+  block_permutation_test_score (block labels permuted): 1 (2%)
+```
+
+The test `test_equivalence_with_reference` checks that, with `exact=False`, the same `random_state` Generator and the same folds, this function returns the same observed score, null scores and p value (except that it returns no null when the observed score is undefined) as the reference implementation used in the analyses (`analyses/step2-comparison/code/sim.py` in the paper's repository; another location can be given with `REFERENCE_SIM_DIR`), for shuffled 5-fold, re-split stratified 5-fold, GroupKFold by block and a user `draw`; it is skipped when that file is not present. With the default `exact="auto"`, designs with no more arrangements than `n_permutations` are enumerated instead (the null then has one score per arrangement).
+
+## Tutorial, MATLAB and Octave
+- `docs/TUTORIAL.md`: a step-by-step guide (folds, strata, pseudosessions, few blocks, fixed block orders, checking a pipeline with labels that carry no information).
+- `matlab/`: a MATLAB and Octave port, `block_permutation_test.m`, which takes a function returning the cross-validated score for a label vector. This Python function is the reference; the port is checked against it in `matlab/crosscheck/` (`matlab/README.md`).
+- On PyPI: `pip install blockperm` (version 0.1.0, the version used in the paper).
+
+## Not included
+No `n_jobs` and no fit parameters (unlike `permutation_test_score`); the permutations run one after another. License: MIT (`LICENSE`).

blockperm-0.1.0/blockperm.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: blockperm
+Version: 0.1.0
+Summary: Block permutation test for cross-validated decoding when labels follow recording blocks
+Author: Dongjin Choi
+License-Expression: MIT
+Project-URL: Repository, https://github.com/jinchoi7651507/block-permutation-decoding
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scikit-learn>=1.4
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# blockperm: a block permutation test for cross-validated decoding
+
+`block_permutation_test_score` tests a cross-validated decoding score when the labels follow recording blocks (for example conditions presented in blocks of consecutive trials) and training and test trials may come from the same blocks. It has the call pattern of scikit-learn's `permutation_test_score`:
+
+```python
+from blockperm import block_permutation_test_score
+
+score, null_scores, p = block_permutation_test_score(
+    pipeline, X, y, blocks=block_id, cv=KFold(5, shuffle=True, random_state=0), n_permutations=1000, random_state=0)
+```
+
+## What it does
+- Each permutation permutes the labels of whole blocks between blocks, so the labels of training and test trials move together and every block keeps its trials.
+- The whole cross-validation is rerun for every permutation, including every step fitted to the labels. Put scaling, feature or neuron selection and the model in one scikit-learn `Pipeline`.
+- `strata` restricts the permutation to blocks within the same stratum (for example within a run or a session).
+- `draw` replaces the permutation with a user-given generator of block-label vectors, for example pseudosessions drawn from the task's own block generator.
+- With few blocks the function enumerates every distinct arrangement (`exact="auto"`) and warns about the smallest attainable p value. With two blocks per class there are six arrangements, but for a two-class decoder an arrangement and its class swap give the same score, so p cannot fall below about one in three.
+
+## When it is valid
+- The enumerated null is exact, and the sampled p value valid, when the observed assignment was drawn uniformly from the set the function permutes over: all arrangements of the block labels, or all arrangements within `strata` if the design randomized within strata (for example within runs). Permuting across a unit the design did not randomize over can reject too often. For a constrained randomization (counterbalancing, limits per run), pass the design's own generator as `draw`.
+- With a fixed block order, the test assumes that blocks are exchangeable under the null. Slow drift that follows the order can break this assumption, and then the test can reject or be conservative. A design with random block order, or several blocks per condition in random order, avoids the problem.
+- With `GroupKFold` and blocks of equal size, the block-to-fold map depends on the tie order of `numpy.argsort`, which differs between platforms (arm64 and x86 gave different maps for 24 blocks with the same versions). For a result that reruns identically elsewhere, pass explicit folds (a list of train/test index pairs) or a shuffled `GroupKFold` with a seed (scikit-learn 1.6 or later), and record the folds.
+
+## Why not the defaults
+In the analyses this function accompanies, three rules that toolboxes run were tested on labels with no information, assigned to recording blocks, with training and test trials sharing blocks:
+- trial-level permutation with the cross-validation rerun (scikit-learn `permutation_test_score`, MVPA-Light);
+- trial-level permutation within runs (the CoSMoMVPA tutorial rule);
+- permutation of training labels only, with test labels kept (the PyMVPA tutorial rule).
+
+All three rejected far more often than 5%. Permuting block labels and rerunning the whole cross-validation stayed near 5% in random block designs. With a fixed block order the result depends on the data. In the simulated fixed orders the test was conservative (0–2.4% with shuffled 5-fold). In resting EEG with fixed orders aligned with slow drift it rejected often (first half against second half in most recordings, a pairs-of-blocks order in 29%), and it stayed near 5% for an order orthogonal to a linear trend. There the blocks were not exchangeable (label = time; see "When it is valid"). With labels that vary trial by trial, the first two rules stayed near 5%, and the training-label rule was somewhat above it (10–12%); the large excess arises when labels follow blocks. `examples/fake_block_labels.py` shows the effect on a synthetic drifting recording.
+
+## One-line changes per tool
+- **scikit-learn:** call `block_permutation_test_score` with `blocks=`. Passing `groups=` to `permutation_test_score` restricts the shuffle to within groups; with labels constant within blocks, every permutation then returns the observed labels.
+- **CoSMoMVPA / PyMVPA:** permute chunk-level labels across chunks (one label per chunk, all trials of a chunk together) within the unit the design randomized over (within runs if blocks were randomized within runs; `strata=` here), and rerun the cross-validation.
+- **PyMVPA training-label permutation:** permute the labels of all trials, training and test, block by block.
+
+## Install and test
+Python 3.12 with numpy, scipy and scikit-learn (tested with numpy 2.5.4, scipy 1.18.1, scikit-learn 1.7.2); tested on macOS (arm64). No special hardware is needed; one CPU core is enough.
+
+```sh
+pip install blockperm           # from PyPI; or, in this folder, pip install ".[test]" (with pytest), or copy blockperm.py into a project
+python -m pytest tests          # a few minutes on one core; the warnings it prints are expected
+python examples/fake_block_labels.py
+```
+
+On a laptop (Apple arm64, 2026-11-10) the install took about 15 s with a network connection, the tests about 1.5 min and the example about 1.5 min. In this folder alone the tests end with "8 passed, 4 skipped" (the equivalence tests need the reference file named below); inside the paper's repository they end with "12 passed". The example prints:
+
+```
+labels with no information, 40 recordings, p < 0.05:
+  permutation_test_score (trial labels permuted): 14 (35%)
+  block_permutation_test_score (block labels permuted): 1 (2%)
+```
+
+The test `test_equivalence_with_reference` checks that, with `exact=False`, the same `random_state` Generator and the same folds, this function returns the same observed score, null scores and p value (except that it returns no null when the observed score is undefined) as the reference implementation used in the analyses (`analyses/step2-comparison/code/sim.py` in the paper's repository; another location can be given with `REFERENCE_SIM_DIR`), for shuffled 5-fold, re-split stratified 5-fold, GroupKFold by block and a user `draw`; it is skipped when that file is not present. With the default `exact="auto"`, designs with no more arrangements than `n_permutations` are enumerated instead (the null then has one score per arrangement).
+
+## Tutorial, MATLAB and Octave
+- `docs/TUTORIAL.md`: a step-by-step guide (folds, strata, pseudosessions, few blocks, fixed block orders, checking a pipeline with labels that carry no information).
+- `matlab/`: a MATLAB and Octave port, `block_permutation_test.m`, which takes a function returning the cross-validated score for a label vector. This Python function is the reference; the port is checked against it in `matlab/crosscheck/` (`matlab/README.md`).
+- On PyPI: `pip install blockperm` (version 0.1.0, the version used in the paper).
+
+## Not included
+No `n_jobs` and no fit parameters (unlike `permutation_test_score`); the permutations run one after another. License: MIT (`LICENSE`).

blockperm-0.1.0/blockperm.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+blockperm.py
+pyproject.toml
+blockperm.egg-info/PKG-INFO
+blockperm.egg-info/SOURCES.txt
+blockperm.egg-info/dependency_links.txt
+blockperm.egg-info/requires.txt
+blockperm.egg-info/top_level.txt
+tests/test_blockperm.py

blockperm-0.1.0/blockperm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

blockperm-0.1.0/blockperm.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy>=2.0
+scikit-learn>=1.4
+
+[test]
+pytest

blockperm-0.1.0/blockperm.egg-info/top_level.txt

@@ -0,0 +1 @@
+blockperm

blockperm-0.1.0/blockperm.py

@@ -0,0 +1,230 @@
+"""Block permutation test for cross-validated decoding when labels follow recording blocks.
+
+`block_permutation_test_score` has the call pattern of scikit-learn's `permutation_test_score`. It differs in what
+it permutes: the labels of whole blocks are permuted between blocks (training and held-out trials together), and
+the whole cross-validation, including every step fitted to the labels, is rerun for every permutation. A label
+vector can instead be drawn from a user-given generator (for example pseudosessions drawn from the task's own
+block generator).
+
+This is the block permutation rule of the accompanying analyses. The enumerated null is exact, and the sampled p
+value valid, when the observed assignment was drawn uniformly from the set the function permutes over: all
+arrangements of the block labels, or all arrangements within strata if the design randomised within strata. For a
+constrained randomisation (counterbalancing, limits per run), pass the design's own generator as `draw`. For a
+fixed block order the test rests on an exchangeability model, not on the randomisation.
+"""
+from __future__ import annotations
+
+import math
+import numbers
+import warnings
+from collections import Counter
+
+import numpy as np
+from sklearn.base import clone, is_classifier
+from sklearn.metrics import check_scoring
+from sklearn.model_selection import check_cv
+
+__all__ = ["block_permutation_test_score", "block_labels_of", "n_distinct_arrangements"]
+
+
+def block_labels_of(y, blocks):
+    """Per-block labels (in the order of np.unique(blocks)) and the position of each trial's block.
+
+    Raises ValueError if a block holds more than one label."""
+    y = np.asarray(y)
+    blocks = np.asarray(blocks)
+    if y.shape[0] != blocks.shape[0]:
+        raise ValueError("y and blocks must have the same length")
+    ub = np.unique(blocks)
+    pos = np.searchsorted(ub, blocks)
+    lab = []
+    for i in range(len(ub)):
+        v = np.unique(y[pos == i])
+        if len(v) != 1:
+            raise ValueError("labels must be constant within blocks (block %r holds %d labels)" % (ub[i], len(v)))
+        lab.append(v[0])
+    return np.array(lab), pos
+
+
+def n_distinct_arrangements(block_labels, strata=None):
+    """Number of distinct block-label vectors reachable by permuting labels between blocks (within strata).
+    Both arguments are per block (one value per block, in the order of np.unique(blocks))."""
+    block_labels = np.asarray(block_labels)
+    strata = None if strata is None else np.asarray(strata)
+    groups = [np.arange(len(block_labels))] if strata is None else [np.where(strata == s)[0] for s in np.unique(strata)]
+    n = 1
+    for g in groups:
+        c = Counter(block_labels[g].tolist())
+        k = math.factorial(len(g))
+        for v in c.values():
+            k //= math.factorial(v)
+        n *= k
+    return n
+
+
+def _cv_score(estimator, X, y, splits, scorer, error_score):
+    scores = []
+    for tr, te in splits:
+        if is_classifier(estimator) and len(np.unique(y[tr])) < 2:
+            return error_score
+        m = clone(estimator).fit(X[tr], y[tr])
+        scores.append(scorer(m, X[te], y[te]))
+    return float(np.mean(scores))
+
+
+def _splits(cv, X, y, groups):
+    with warnings.catch_warnings():            # splitters that ignore groups (KFold, StratifiedKFold) warn
+        warnings.filterwarnings("ignore", message="The groups parameter is ignored")
+        return list(cv.split(X, y, groups))
+
+
+def block_permutation_test_score(estimator, X, y, *, blocks, cv=None, n_permutations=1000, scoring=None,
+                                 random_state=None, strata=None, draw=None, groups="blocks", exact="auto",
+                                 error_score=np.nan):
+    """Evaluate the significance of a cross-validated score by permuting labels between blocks.
+
+    Parameters
+    ----------
+    estimator : scikit-learn estimator (a Pipeline with every label-fitted step: scaling, selection, model)
+    X : array (n_trials, n_features)
+    y : array (n_trials,), constant within each block
+    blocks : array (n_trials,), block identity of each trial (a recording block of consecutive trials)
+    cv : as in scikit-learn (int, splitter or iterable); default 5-fold. A splitter is re-applied to every
+        permuted label vector (as scikit-learn does), so label-stratified folds follow the permuted labels.
+    n_permutations : number of permutations (ignored when the exact enumeration is used)
+    scoring : as in scikit-learn; default the estimator's score (accuracy for classifiers). The score is the mean
+        over folds, as in `permutation_test_score`.
+    random_state : int, numpy Generator, RandomState or None (passed to numpy.random.default_rng unless a
+        Generator); the permutations use this stream only, so the same Generator and folds reproduce the same null
+    strata : optional array (n_trials,), constant within blocks: labels are permuted only between blocks of the
+        same stratum. Use the unit the design randomised over (for example within runs if blocks were randomised
+        within runs); permuting across that unit can reject too often.
+    draw : optional callable(rng) -> per-block label vector (order of np.unique(blocks)); replaces the
+        permutation, for example to draw pseudosessions from the task's generator. `strata` and `exact` are
+        ignored when `draw` is given.
+    groups : "blocks" (default) passes the block identity to `cv.split` as `groups`, so GroupKFold-type splitters
+        hold out whole blocks; None passes nothing; an array is passed as given.
+    exact : "auto" enumerates all distinct block-label arrangements when there are no more of them than
+        `n_permutations` (the null then has one score per arrangement, the observed one included, and its length
+        is the number of arrangements, not `n_permutations`); True forces the enumeration (at most 100,000
+        arrangements); False always samples with replacement.
+    error_score : number used as the score of a cross-validation with a one-class training fold (classifiers).
+        Other fit errors are raised. NaN null scores count as exceedances (conservative); an undefined observed
+        score returns p = NaN with a warning.
+
+    Returns
+    -------
+    score : float, observed cross-validated score
+    permutation_scores : array, scores under the null (empty when the observed score is undefined; the
+        reference implementation returned its full null in that case, with p NaN as here)
+    pvalue : float, (1 + #{null >= score} + #{null NaN}) / (n_null + 1) when sampling; when enumerating,
+        (1 + #{other arrangements with score >= observed or NaN}) / (number of arrangements), the observed
+        arrangement counted once with its observed score (also when the cross-validation is not deterministic).
+    """
+    X = np.asarray(X)
+    y = np.asarray(y)
+    blocks = np.asarray(blocks)
+    if X.shape[0] != y.shape[0] or blocks.shape[0] != y.shape[0]:
+        raise ValueError("X, y and blocks must have the same number of trials")
+    if not (isinstance(exact, (bool, np.bool_)) or (isinstance(exact, str) and exact == "auto")):
+        raise ValueError('exact must be "auto", True or False')
+    exact = exact if isinstance(exact, str) else bool(exact)
+    if not isinstance(n_permutations, numbers.Integral) or isinstance(n_permutations, bool) or n_permutations < 1:
+        raise ValueError("n_permutations must be an integer of at least 1")
+    if isinstance(groups, str) and groups != "blocks":
+        raise ValueError('groups must be "blocks", None or an array with one value per trial')
+    if not isinstance(error_score, numbers.Real) or isinstance(error_score, (bool, np.bool_)):
+        raise ValueError("error_score must be a number (NaN by default)")
+    lab, pos = block_labels_of(y, blocks)
+    rng = random_state if isinstance(random_state, np.random.Generator) else np.random.default_rng(random_state)
+    cv = check_cv(cv, y, classifier=is_classifier(estimator))
+    scorer = check_scoring(estimator, scoring=scoring)
+    g = blocks if isinstance(groups, str) else groups
+    if strata is not None:
+        if np.asarray(strata).shape[0] != y.shape[0]:
+            raise ValueError("strata must have one value per trial")
+        st_lab, _ = block_labels_of(np.asarray(strata), blocks)
+    else:
+        st_lab = None
+
+    score = _cv_score(estimator, X, y, _splits(cv, X, y, g), scorer, error_score)
+    if not np.isfinite(score):
+        warnings.warn("the observed score is undefined (a training fold with one class, or a scorer that returned "
+                      "NaN); p is NaN and no null was computed", stacklevel=2)
+        return score, np.array([], float), float("nan")
+
+    n_arr = n_distinct_arrangements(lab, st_lab) if draw is None else None
+    use_exact = draw is None and (exact is True or (exact == "auto" and n_arr <= n_permutations))
+    if draw is None and n_arr < 20:
+        warnings.warn("only %d distinct block-label arrangements: with exact enumeration p cannot fall below %.3g, "
+                      "and not below %.3g when swapping the two classes leaves the score unchanged (a refit two-class "
+                      "classifier with balanced blocks)%s"
+                      % (n_arr, 1.0 / n_arr, 2.0 / n_arr, "" if use_exact else "; consider exact=True"), stacklevel=2)
+
+    if use_exact:
+        if n_arr > 100_000:
+            raise ValueError("too many arrangements to enumerate (%d)" % n_arr)
+        arrangements = _enumerate(lab, st_lab)
+        obs = next(i for i, a in enumerate(arrangements) if np.array_equal(a, lab))
+        null = np.array([score if i == obs else
+                         _cv_score(estimator, X, a[pos], _splits(cv, X, a[pos], g), scorer, error_score)
+                         for i, a in enumerate(arrangements)])
+        others = np.delete(null, obs)
+        ge = 1 + np.sum(others[~np.isnan(others)] >= score - 1e-12) + np.isnan(others).sum()
+        return score, null, float(ge / len(null))
+
+    null = []
+    for _ in range(n_permutations):
+        if draw is not None:
+            lp = np.asarray(draw(rng))
+            if lp.shape != lab.shape:
+                raise ValueError("draw must return one label per block")
+        elif st_lab is None:
+            lp = rng.permutation(lab)
+        else:
+            lp = lab.copy()
+            for s in np.unique(st_lab):
+                i = np.where(st_lab == s)[0]
+                lp[i] = lab[rng.permutation(i)]
+        yp = lp[pos]
+        null.append(_cv_score(estimator, X, yp, _splits(cv, X, yp, g), scorer, error_score))
+    null = np.array(null, float)
+    p = (1 + np.sum(null[~np.isnan(null)] >= score - 1e-12) + np.isnan(null).sum()) / (len(null) + 1)
+    return score, null, float(p)
+
+
+def _multiset_permutations(items):
+    """Distinct orderings of a list with repeated values, each once (no n! intermediate list)."""
+    counts = Counter(items)
+    keys = sorted(counts)
+    n = len(items)
+    cur = []
+
+    def rec():
+        if len(cur) == n:
+            yield tuple(cur)
+            return
+        for k in keys:
+            if counts[k]:
+                counts[k] -= 1
+                cur.append(k)
+                yield from rec()
+                cur.pop()
+                counts[k] += 1
+    yield from rec()
+
+
+def _enumerate(lab, st_lab):
+    """All distinct block-label vectors reachable by permuting within strata (observed one included)."""
+    idx_groups = [np.arange(len(lab))] if st_lab is None else [np.where(st_lab == s)[0] for s in np.unique(st_lab)]
+    per_group = [list(_multiset_permutations(lab[i].tolist())) for i in idx_groups]
+    out = []
+    def rec(k, cur):
+        if k == len(idx_groups):
+            out.append(cur.copy())
+            return
+        for arr in per_group[k]:
+            cur[idx_groups[k]] = arr
+            rec(k + 1, cur)
+    rec(0, lab.copy())
+    return out

blockperm-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "blockperm"
+version = "0.1.0"
+description = "Block permutation test for cross-validated decoding when labels follow recording blocks"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Dongjin Choi"}]
+requires-python = ">=3.12"
+dependencies = ["numpy>=2.0", "scikit-learn>=1.4"]
+
+[project.urls]
+Repository = "https://github.com/jinchoi7651507/block-permutation-decoding"
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools]
+py-modules = ["blockperm"]

blockperm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

blockperm-0.1.0/tests/test_blockperm.py

@@ -0,0 +1,226 @@
+"""Tests of block_permutation_test_score (no study data; synthetic recordings only)."""
+import os
+import sys
+import warnings
+from pathlib import Path
+
+import numpy as np
+import pytest
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import KFold, StratifiedKFold, GroupKFold, permutation_test_score
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from blockperm import block_permutation_test_score, block_labels_of, n_distinct_arrangements  # noqa: E402
+
+_HERE = Path(__file__).resolve()
+_CANDIDATES = [_HERE.parents[2] / "analyses" / "step2-comparison" / "code",      # public repository layout
+               _HERE.parents[3] / "results" / "step2-comparison" / "code"]       # working-repository layout
+REFERENCE = Path(os.environ.get("REFERENCE_SIM_DIR", next((c for c in _CANDIDATES if (c / "sim.py").exists()), _CANDIDATES[0])))
+
+
+def reference_sim():
+    """The reference implementation used in the analyses (read only; no bytecode written next to it)."""
+    old = sys.dont_write_bytecode
+    sys.dont_write_bytecode = True
+    sys.path.insert(0, str(REFERENCE))
+    try:
+        import sim
+    finally:
+        sys.dont_write_bytecode = old
+    return sim
+
+
+def lr():
+    return Pipeline([("scale", StandardScaler()), ("lr", LogisticRegression(C=1.0, max_iter=1000))])
+
+
+def drifting_counts(n_trials, n_units, rng, tau=20.0, sd=0.6):
+    """Poisson counts with one slow shared AR(1) factor (no label signal)."""
+    a = np.exp(-1.0 / tau)
+    z = np.empty(n_trials)
+    z[0] = rng.standard_normal()
+    e = rng.standard_normal(n_trials) * np.sqrt(1 - a * a)
+    for t in range(1, n_trials):
+        z[t] = a * z[t - 1] + e[t]
+    load = rng.standard_normal(n_units)
+    return rng.poisson(np.exp(np.log(5.0) + sd * z[:, None] * load[None, :])).astype(float)
+
+
+def random_block_design(n_blocks, block_len, rng):
+    blocks = np.repeat(np.arange(n_blocks), block_len)
+    lab = np.zeros(n_blocks, int)
+    lab[rng.choice(n_blocks, n_blocks // 2, replace=False)] = 1
+    return blocks, lab[blocks]
+
+
+@pytest.mark.skipif(not (REFERENCE / "sim.py").exists(), reason="reference sim.py not found")
+@pytest.mark.parametrize("split", ["main", "tool", "block", "draw"])
+def test_equivalence_with_reference(split):
+    """Same data, folds and random stream (exact=False): identical observed score, null scores and p as the
+    reference implementation, for shuffled 5-fold, re-split stratified 5-fold, GroupKFold by block and a user draw."""
+    sim = reference_sim()
+    rng = np.random.default_rng(11)
+    blocks, y = random_block_design(12, 20, rng)
+    X = sim.simulate2(240, rng, n_units=40, tau_s=20.0)
+    est = sim.pipeline(k=20)
+    draw = None
+    if split in ("main", "draw"):
+        fl = sim.folds("main", X, y, blocks, seed=5)
+        cv_new, groups = fl, None
+        if split == "draw":
+            draw = lambda g: g.permutation(np.array([0, 1] * 6))
+    elif split == "tool":
+        fl = sim.Resplit(StratifiedKFold(5), blocks)
+        cv_new, groups = StratifiedKFold(5), "blocks"
+    else:
+        fl = sim.folds("block", X, y, blocks, seed=5)
+        cv_new, groups = GroupKFold(5), "blocks"
+    obs, null, p = sim.block_permutation_test_score(est, X, y, blocks, fl, 40, np.random.default_rng(3), draw=draw)
+    s2, null2, p2 = block_permutation_test_score(est, X, y, blocks=blocks, cv=cv_new, n_permutations=40,
+                                                 random_state=np.random.default_rng(3), groups=groups, exact=False,
+                                                 draw=draw)
+    assert s2 == pytest.approx(obs, abs=1e-12)
+    np.testing.assert_allclose(null2, null, atol=1e-12)
+    assert p2 == pytest.approx(p, abs=1e-12)
+
+
+def test_exact_p_is_valid_over_all_arrangements():
+    """6 blocks, 3 per label: 20 arrangements. Taking each in turn as the observed one, the share with p <= alpha
+    is at most alpha (the exact randomisation property), at alpha 0.05, 0.10 and 0.25."""
+    rng = np.random.default_rng(8)
+    blocks = np.repeat(np.arange(6), 20)
+    X = drifting_counts(120, 8, rng)
+    cv = KFold(5, shuffle=True, random_state=0)
+    from blockperm import _enumerate
+    arrs = _enumerate(np.array([0, 0, 0, 1, 1, 1]), None)
+    assert len(arrs) == 20
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        ps = np.array([block_permutation_test_score(lr(), X, a[blocks], blocks=blocks, cv=cv, groups=None,
+                                                    exact=True)[2] for a in arrs])
+    assert np.all(ps >= 1 / 20 - 1e-12)
+    for alpha in (0.05, 0.10, 0.25):
+        assert np.mean(ps <= alpha + 1e-12) <= alpha + 1e-12
+
+
+def test_exact_p_not_below_one_over_n_with_random_folds():
+    """Shuffled folds without a seed differ between calls; the observed arrangement still counts once."""
+    rng = np.random.default_rng(9)
+    blocks = np.repeat(np.arange(6), 20)
+    y = np.array([0, 1, 0, 1, 0, 1])[blocks]
+    X = drifting_counts(120, 8, rng)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        for _ in range(3):
+            _, null, p = block_permutation_test_score(lr(), X, y, blocks=blocks, cv=KFold(5, shuffle=True),
+                                                      groups=None, exact=True)
+            assert len(null) == 20 and p >= 1 / 20 - 1e-12
+
+
+def test_size_under_drift_and_contrast_with_trial_permutation():
+    """Random block assignment with slow drift, no signal: the block test stays near 5%; scikit-learn's
+    trial-level permutation_test_score with shuffled 5-fold rejects far more often (the failure it replaces)."""
+    reps, n_perm = 60, 49
+    rej_block, rej_trial = 0, 0
+    for r in range(reps):
+        rng = np.random.default_rng(1000 + r)
+        blocks, y = random_block_design(12, 20, rng)
+        X = drifting_counts(240, 20, rng)
+        cv = KFold(5, shuffle=True, random_state=r)
+        _, _, p = block_permutation_test_score(lr(), X, y, blocks=blocks, cv=cv, n_permutations=n_perm,
+                                               random_state=r, groups=None, exact=False)
+        _, _, pt = permutation_test_score(lr(), X, y, cv=cv, n_permutations=n_perm, random_state=r)
+        rej_block += p < 0.05
+        rej_trial += pt < 0.05
+    assert rej_block / reps <= 0.14          # 99% binomial upper limit for 5% at n = 60 is about 0.13
+    assert rej_trial / reps >= 0.30
+
+
+def test_exact_enumeration_small_design():
+    rng = np.random.default_rng(2)
+    blocks, y = random_block_design(4, 30, rng)
+    X = drifting_counts(120, 10, rng)
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        s, null, p = block_permutation_test_score(lr(), X, y, blocks=blocks, cv=GroupKFold(4), n_permutations=1000,
+                                                  random_state=0)
+    assert any("distinct block-label arrangements" in str(x.message) for x in w)
+    assert len(null) == 6                     # 4 blocks, 2 per label: 4!/(2!2!) arrangements
+    assert p >= 1 / 6 - 1e-12
+    assert np.any(np.isclose(null, s))        # the observed arrangement is one of them
+
+
+def test_strata_restrict_permutations():
+    rng = np.random.default_rng(4)
+    blocks = np.repeat(np.arange(8), 15)
+    lab = np.array([0, 1, 0, 1, 1, 0, 1, 0])
+    y = lab[blocks]
+    strata = (blocks >= 4).astype(int)        # two halves, 2 + 2 blocks per label in each
+    assert n_distinct_arrangements(lab, None) == 70
+    assert n_distinct_arrangements(lab, np.array([0, 0, 0, 0, 1, 1, 1, 1])) == 36
+    X = drifting_counts(120, 10, rng)
+    _, null, _ = block_permutation_test_score(lr(), X, y, blocks=blocks, cv=KFold(5, shuffle=True, random_state=0),
+                                              n_permutations=36, random_state=0, strata=strata, groups=None,
+                                              exact=True)
+    assert len(null) == 36
+
+
+def test_draw_generator_is_used():
+    rng = np.random.default_rng(5)
+    blocks, y = random_block_design(10, 20, rng)
+    X = drifting_counts(200, 10, rng)
+    fixed = np.array([0, 1] * 5)
+    cv = KFold(5, shuffle=True, random_state=0)
+    _, null, _ = block_permutation_test_score(lr(), X, y, blocks=blocks, cv=cv, n_permutations=5,
+                                              random_state=0, draw=lambda g: fixed, groups=None)
+    ref, _, _ = block_permutation_test_score(lr(), X, fixed[blocks], blocks=blocks, cv=cv, n_permutations=1,
+                                             random_state=0, groups=None, exact=False)
+    np.testing.assert_allclose(null, ref)
+
+
+def test_input_errors():
+    blocks = np.repeat(np.arange(6), 10)
+    y = np.repeat([0, 1, 0, 1, 0, 1], 10)
+    y_bad = y.copy()
+    y_bad[3] = 1 - y_bad[3]
+    X = np.random.default_rng(0).standard_normal((60, 4))
+    with pytest.raises(ValueError, match="constant within blocks"):
+        block_permutation_test_score(lr(), X, y_bad, blocks=blocks)
+    with pytest.raises(ValueError, match="one label per block"):
+        block_permutation_test_score(lr(), X, y, blocks=blocks, draw=lambda g: np.zeros(3), n_permutations=2)
+    with pytest.raises(ValueError, match="groups must be"):
+        block_permutation_test_score(lr(), X, y, blocks=blocks, groups="block")
+    with pytest.raises(ValueError, match="exact must be"):
+        block_permutation_test_score(lr(), X, y, blocks=blocks, exact="yes")
+    with pytest.raises(ValueError, match="at least 1"):
+        block_permutation_test_score(lr(), X, y, blocks=blocks, n_permutations=1.5)
+    with pytest.raises(ValueError, match="one value per trial"):
+        block_permutation_test_score(lr(), X, y, blocks=blocks, strata=np.zeros(5))
+    with pytest.raises(ValueError, match="at least 1"):
+        block_permutation_test_score(lr(), X, y, blocks=blocks, n_permutations=0)
+    with pytest.raises(ValueError, match="error_score"):
+        block_permutation_test_score(lr(), X, y, blocks=blocks, error_score="raise")
+    with pytest.raises(ValueError, match="same number of trials"):
+        block_permutation_test_score(lr(), X[:50], y, blocks=blocks)
+
+
+def test_single_class_training_fold_counts_as_exceedance():
+    """Folds hold out blocks {2, 3} and {0, 1}. Observed labels 0101 give two classes in every training fold;
+    the arrangements 0011 and 1100 leave one class in training, score NaN and count as exceedances. An observed
+    arrangement with a one-class training fold gives p = NaN."""
+    blocks = np.repeat(np.arange(4), 10)
+    lab, _ = block_labels_of(np.repeat([0, 0, 1, 1], 10), blocks)
+    assert list(lab) == [0, 0, 1, 1]
+    i01, i23 = np.where(blocks < 2)[0], np.where(blocks >= 2)[0]
+    folds = [(i01, i23), (i23, i01)]
+    X = np.random.default_rng(1).standard_normal((40, 3))
+    y = np.repeat([0, 1, 0, 1], 10)
+    s, null, p = block_permutation_test_score(lr(), X, y, blocks=blocks, cv=folds, groups=None, random_state=0)
+    assert np.isfinite(s) and np.isnan(null).sum() == 2 and len(null) == 6
+    ge = np.sum(null[~np.isnan(null)] >= s - 1e-12) + np.isnan(null).sum()
+    assert p == pytest.approx(ge / len(null))
+    _, _, p_bad = block_permutation_test_score(lr(), X, np.repeat([0, 0, 1, 1], 10), blocks=blocks, cv=folds,
+                                               groups=None, random_state=0)
+    assert np.isnan(p_bad)