CORTEG Stanford pooled model, converted from the official release

LICENSE

@@ -0,0 +1,50 @@
+The CORTEG adapter (checkpoints/corteg_stanford_pooled.pt of
+https://github.com/LiuyinYang1101/CORTEG at caafb78fbebdd9448814f96d7e61083a3eb62663):
+
+MIT License
+
+Copyright (c) 2026 Liuyin Yang
+
+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.
+
+
+The ST-EEGFormer small backbone (release ST-EEGFormer-small of
+https://github.com/LiuyinYang1101/STEEGFormer):
+
+MIT License
+
+Copyright (c) 2025 LIUYIN YANG
+
+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.

README.md

@@ -0,0 +1,93 @@
+---
+library_name: braindecode
+license: mit
+base_model: braindecode/STEEGFormer-small
+tags:
+- braindecode
+- CORTEG
+- ieeg
+- ecog
+- finger-flexion
+- pytorch_model_hub_mixin
+---
+
+# CORTEG, Stanford finger flexion (pooled)
+
+The released CORTEG model of [Yang et al. (2026)](https://arxiv.org/abs/2605.10337),
+ST-EEGFormer small adapted to ECoG and trained on the finger-flexion recordings
+of the 9 Stanford patients pooled (Table 1, "CORTEG (pooled)", Pearson r 0.554),
+25.5M parameters, converted to
+[`braindecode.models.CORTEG`](https://braindecode.org/stable/generated/braindecode.models.CORTEG.html).
+It decodes the flexion of the five fingers (thumb, index, middle, ring, pinky) from 1 s of ECoG.
+
+Sources:
+
+- the adapter, `checkpoints/corteg_stanford_pooled.pt` of [LiuyinYang1101/CORTEG](https://github.com/LiuyinYang1101/CORTEG/tree/caafb78fbebdd9448814f96d7e61083a3eb62663),
+  sha256 `77d63a214e0e0f2c790e90878a0ef6b525f6e24e1453fcd94e118c63ff7e8396`: the spatial adapter, LoRA factors (r=4, alpha=16) on
+  blocks 4-7, the high-gamma patch embedding, those blocks' LayerNorms and the
+  readout, 297,236 parameters;
+- the frozen backbone it was trained on, the ST-EEGFormer small release
+  ([`checkpoint-300.pth`](https://github.com/LiuyinYang1101/STEEGFormer/releases/download/ST-EEGFormer-small/checkpoint-300.pth), sha256 `98d2848abdaea7a143d399c07f67f8782e07dd66e7c309ddb058c7158a8a8b02`), here
+  through its conversion [braindecode/STEEGFormer-small](https://huggingface.co/braindecode/STEEGFormer-small)
+  at revision `633c9c0d`.
+
+Conversion folds the LoRA factors into the fused qkv, proj, fc1 and fc2 weights
+(scale alpha/r = 4), so the model is a plain `CORTEG`;
+`convert_corteg_checkpoint.py` in this repository reproduces it. Outputs match
+the authors' `load_corteg` on the two release files to 1.5e-06
+in float32 on CPU, for montages of 8 and 46
+contacts.
+
+## Usage
+
+The model reads two streams of the same 1 s window, as the paper's Stanford
+pipeline (`data/stanford_preprocessing/` of the official repository): after a
+notch at 60, 120 and 180 Hz and a common average reference, `x` is the signal
+resampled to 128 Hz and `x_hi` its 70-200 Hz Hilbert envelope at 200 Hz, each
+z-scored per channel with the statistics of the training windows. Electrode
+positions are in metres, in `chs_info` or `pos`.
+
+```python
+import torch
+from braindecode.models import CORTEG
+
+model = CORTEG.from_pretrained(
+    "braindecode/corteg-stanford-pooled", chs_info=raw.info["chs"]
+).eval()
+flexion = model(x, x_hi)  # x: (batch, n_chans, 128), x_hi: (batch, n_chans, 200)
+```
+
+The output, `(batch, 5)`, is the flexion of each finger, z-scored per finger
+with the training statistics of the patient, at the time 40 ms before the
+window's end. The saved geometry is 8 channels; the model
+reads any montage, so pass your own `chs_info` (or `n_chans` and `pos` at each
+call) when loading.
+
+## Limitations
+
+The readout is at its random initialization, as released: the paper run built
+it after the optimizer, so it was never trained, and the adapter learned around
+it (see the release manifest, `checkpoints/corteg_stanford_pooled.json`).
+The model was trained on the training split of the 9 Stanford patients (the
+first 400 s of each recording, two thirds of one under 600 s); other patients
+or tasks need fine-tuning, as in the paper's leave-one-subject-out protocol. The check above covers float32 CPU outputs, not
+decoding accuracy, GPU kernels or mixed precision; the authors report that this
+checkpoint reproduces the cohort mean of 0.554 (manifest, `paper.verified`).
+
+## Citation
+
+```bibtex
+@inproceedings{yang2026corteg,
+  title     = {{CORTEG}: Foundation Models Enable Cross-Modality Representation Transfer
+               from Scalp to Intracranial Brain Recordings},
+  author    = {Yang, Liuyin and Sun, Qiang and Van Dyck, Bob and Calvo Merino, Eva and
+               Van Hulle, Marc M.},
+  booktitle = {Advances in Neural Information Processing Systems (NeurIPS)},
+  year      = {2026}
+}
+```
+
+## License
+
+The adapter and the ST-EEGFormer backbone are both released by Liuyin Yang
+under the MIT licence (`LICENSE`). Braindecode's code is BSD-3-Clause.

config.json

@@ -0,0 +1,26 @@
+{
+  "n_outputs": 5,
+  "n_chans": 8,
+  "chs_info": null,
+  "n_times": 128,
+  "input_window_seconds": null,
+  "sfreq": 128.0,
+  "patch_size": 16,
+  "hi_patch_size": 25,
+  "embed_dim": 512,
+  "depth": 8,
+  "num_heads": 8,
+  "mlp_ratio": 4,
+  "drop_prob": 0.0,
+  "drop_path": 0.1,
+  "activation": "torch.nn.modules.activation.GELU",
+  "n_chans_pos": 145,
+  "merge_strategy": "average",
+  "n_merge_blocks": 4,
+  "knn_k": 8,
+  "adapter_hidden": 128,
+  "n_fourier_freqs": 32,
+  "gate_bottleneck": 16,
+  "on_non_divisible": "pad",
+  "braindecode_version": "2.1.0dev0"
+}

convert_corteg_checkpoint.py

@@ -0,0 +1,370 @@
+# Authors: Julien Gadonneix <juliengado.2001@gmail.com>
+# License: BSD (3-clause)
+"""Convert, check and publish the released CORTEG Stanford model on CPU.
+
+Run from an editable Braindecode checkout containing CORTEG, with the ``hub``
+extra and ``timm`` and ``einops`` (for the reference) installed::
+
+    git clone https://github.com/LiuyinYang1101/CORTEG && git -C CORTEG checkout caafb78
+    curl -L -o checkpoint-300.pth \\
+        https://github.com/LiuyinYang1101/STEEGFormer/releases/download/ST-EEGFormer-small/checkpoint-300.pth
+    python convert_corteg_checkpoint.py --reference-dir CORTEG \\
+        --backbone checkpoint-300.pth --output-dir /tmp/corteg-converted
+
+``--reference-dir`` is a clone of the official repository at ``REVISION``, which
+ships the adapter (``ADAPTER``); ``--backbone`` is the ST-EEGFormer small
+release it was trained on. The SHA-256 values below must match. The released
+adapter holds the trainable parameters only: the spatial adapter, LoRA factors
+on blocks 4-7, the high-gamma patch embedding, those blocks' LayerNorms and the
+readout. The port takes the frozen backbone from its Braindecode conversion
+(``BACKBONE_REPO`` at ``BACKBONE_REVISION``) and folds the LoRA factors into the
+fused qkv, proj, fc1 and fc2 weights, so the published model is a plain
+``CORTEG``. The authors' ``load_corteg`` builds the reference from the same two
+release files; both run on the same inputs and their outputs must agree within
+``TOLERANCE``. Download this script from the Braindecode CORTEG model
+repository on Hugging Face; it is not bundled in the Braindecode source tree.
+
+Add ``--push-to braindecode`` to upload the converted model, this script, the
+MIT licences of the adapter and backbone, a report and a model card in one
+commit.
+"""
+
+import argparse
+import hashlib
+import json
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import torch
+from huggingface_hub import HfApi, hf_hub_download
+from safetensors.torch import load_file
+
+from braindecode.models import CORTEG
+
+REPOSITORY = "https://github.com/LiuyinYang1101/CORTEG"
+REVISION = "caafb78fbebdd9448814f96d7e61083a3eb62663"
+ADAPTER = "checkpoints/corteg_stanford_pooled.pt"
+ADAPTER_SHA256 = "77d63a214e0e0f2c790e90878a0ef6b525f6e24e1453fcd94e118c63ff7e8396"
+ADAPTER_PARAMS = 297_236  # the release manifest's trainable_params
+BACKBONE_URL = (
+    "https://github.com/LiuyinYang1101/STEEGFormer/releases/download/"
+    "ST-EEGFormer-small/checkpoint-300.pth"
+)
+BACKBONE_SHA256 = "98d2848abdaea7a143d399c07f67f8782e07dd66e7c309ddb058c7158a8a8b02"
+BACKBONE_REPO = "braindecode/STEEGFormer-small"
+BACKBONE_REVISION = "633c9c0d76c6e26459e1e0d1337c91858578f13d"
+HUB_REPO = "corteg-stanford-pooled"
+# The released run (manifest architecture_args): 1 s windows of 128 low-frequency
+# and 200 high-gamma samples, five fingers, the "average" fusion before the last
+# four blocks.
+CONFIG = dict(
+    n_outputs=5,
+    n_times=128,
+    sfreq=128.0,
+    merge_strategy="average",
+    n_merge_blocks=4,
+    hi_patch_size=25,
+    knn_k=8,
+    drop_path=0.1,
+)
+LORA_SCALE = 16 / 4  # alpha / r
+# Reference layer of a block -> its Braindecode modules; the fused qkv splits in three.
+LAYERS = {
+    "norm1": ["0.fn.0"],
+    "norm2": ["1.fn.0"],
+    "attn.qkv": ["0.fn.1.queries", "0.fn.1.keys", "0.fn.1.values"],
+    "attn.proj": ["0.fn.1.projection"],
+    "mlp.fc1": ["1.fn.1.0"],
+    "mlp.fc2": ["1.fn.1.3"],
+}
+TOLERANCE = 1e-4
+FINGERS = ["thumb", "index", "middle", "ring", "pinky"]
+MIT = """MIT License
+
+Copyright (c) {year} {holder}
+
+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.
+"""
+LICENSE = (
+    "The CORTEG adapter (checkpoints/corteg_stanford_pooled.pt of\n"
+    f"{REPOSITORY} at {REVISION}):\n\n"
+    + MIT.format(year=2026, holder="Liuyin Yang")
+    + "\n\nThe ST-EEGFormer small backbone (release ST-EEGFormer-small of\n"
+    "https://github.com/LiuyinYang1101/STEEGFormer):\n\n"
+    + MIT.format(year=2025, holder="LIUYIN YANG")
+)
+
+
+def sha256(path):
+    digest = hashlib.sha256()
+    with open(path, "rb") as f:
+        for block in iter(lambda: f.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def montages():
+    """Electrode positions in metres: the Braindecode test montage and 46 random contacts."""
+    rng = np.random.default_rng(0)
+    random = rng.uniform([-0.07, -0.10, -0.04], [0.07, 0.07, 0.08], size=(46, 3))
+    return [
+        torch.tensor(
+            [[-0.04 + 0.004 * i, -0.02 + 0.003 * i, 0.06 - 0.002 * i] for i in range(8)]
+        ),
+        torch.tensor(random, dtype=torch.float32),
+    ]
+
+
+def convert(adapter, model):
+    """Load the backbone and the adapter into ``model``, the LoRA factors folded in."""
+    path = hf_hub_download(BACKBONE_REPO, "model.safetensors", revision=BACKBONE_REVISION)
+    backbone = {k: v for k, v in load_file(path).items() if not k.startswith("final_layer.")}
+    missing, unexpected = model.load_state_dict(backbone, strict=False)
+    if unexpected or {k.split(".")[0] for k in missing} != {"channel_adapter", "final_layer"}:
+        raise SystemExit(f"backbone does not fit CORTEG: {missing=}, {unexpected=}")
+    state = model.state_dict()
+    filled = set()
+    for key, value in adapter.items():
+        key = key.removeprefix("backbone.").replace("head.head.", "final_layer.")
+        if not key.startswith("blocks."):
+            if key not in state or state[key].shape != value.shape:
+                raise SystemExit(f"adapter tensor {key} has no home in CORTEG")
+            state[key] = value
+            filled.add(key)
+            continue
+        _, block, rest = key.split(".", 2)
+        layer, _, param = rest.rpartition(".")
+        if layer.endswith(".B"):  # folded with its A factor
+            continue
+        if layer.endswith(".A"):
+            layer = layer.removesuffix(".A")
+            lora_b = adapter[f"backbone.blocks.{block}.{layer}.B.weight"]
+            delta = (LORA_SCALE * lora_b @ value).chunk(len(LAYERS[layer]))
+            for name, part in zip(LAYERS[layer], delta):
+                state[f"encoder.{block}.{name}.weight"] += part
+        else:
+            target = f"encoder.{block}.{LAYERS[layer][0]}.{param}"
+            state[target] = value
+            filled.add(target)
+    unfilled = {k for k in missing if k not in filled}
+    if unfilled:
+        raise SystemExit(f"the adapter leaves {sorted(unfilled)} at their initialization")
+    model.load_state_dict(state, strict=True)
+
+
+def reference_outputs(reference_dir, backbone, x, x_hi, pos):
+    """Outputs of the authors' ``load_corteg`` on the two release files."""
+    sys.path.insert(0, str(reference_dir))
+    from load_corteg import load_corteg, predict
+
+    config = json.loads((reference_dir / "configs/steegformer_small.json").read_text())
+    config["pretrained"]["path"] = str(backbone.resolve())
+    with tempfile.TemporaryDirectory() as tmp:
+        config_path = Path(tmp) / "steegformer_small.json"
+        config_path.write_text(json.dumps(config))
+        reference = load_corteg(
+            C_in=x.shape[1],
+            T_in=x.shape[2],
+            ecog_xyz_mm=1000 * pos.numpy(),
+            d_out=CONFIG["n_outputs"],
+            backbone_config=str(config_path),
+        )
+    return torch.from_numpy(predict(reference, x.numpy(), x_hi.numpy()))
+
+
+def model_card(report):
+    return f"""---
+library_name: braindecode
+license: mit
+base_model: {BACKBONE_REPO}
+tags:
+- braindecode
+- CORTEG
+- ieeg
+- ecog
+- finger-flexion
+- pytorch_model_hub_mixin
+---
+
+# CORTEG, Stanford finger flexion (pooled)
+
+The released CORTEG model of [Yang et al. (2026)](https://arxiv.org/abs/2605.10337),
+ST-EEGFormer small adapted to ECoG and trained on the finger-flexion recordings
+of the 9 Stanford patients pooled (Table 1, "CORTEG (pooled)", Pearson r 0.554),
+{report["n_params"] / 1e6:.1f}M parameters, converted to
+[`braindecode.models.CORTEG`](https://braindecode.org/stable/generated/braindecode.models.CORTEG.html).
+It decodes the flexion of the five fingers ({", ".join(FINGERS)}) from 1 s of ECoG.
+
+Sources:
+
+- the adapter, `{ADAPTER}` of [LiuyinYang1101/CORTEG]({REPOSITORY}/tree/{REVISION}),
+  sha256 `{ADAPTER_SHA256}`: the spatial adapter, LoRA factors (r=4, alpha=16) on
+  blocks 4-7, the high-gamma patch embedding, those blocks' LayerNorms and the
+  readout, {ADAPTER_PARAMS:,} parameters;
+- the frozen backbone it was trained on, the ST-EEGFormer small release
+  ([`checkpoint-300.pth`]({BACKBONE_URL}), sha256 `{BACKBONE_SHA256}`), here
+  through its conversion [{BACKBONE_REPO}](https://huggingface.co/{BACKBONE_REPO})
+  at revision `{BACKBONE_REVISION[:8]}`.
+
+Conversion folds the LoRA factors into the fused qkv, proj, fc1 and fc2 weights
+(scale alpha/r = 4), so the model is a plain `CORTEG`;
+`convert_corteg_checkpoint.py` in this repository reproduces it. Outputs match
+the authors' `load_corteg` on the two release files to {report["max_abs_diff"]:.1e}
+in float32 on CPU, for montages of {" and ".join(str(n) for n in report["n_chans_checked"])}
+contacts.
+
+## Usage
+
+The model reads two streams of the same 1 s window, as the paper's Stanford
+pipeline (`data/stanford_preprocessing/` of the official repository): after a
+notch at 60, 120 and 180 Hz and a common average reference, `x` is the signal
+resampled to 128 Hz and `x_hi` its 70-200 Hz Hilbert envelope at 200 Hz, each
+z-scored per channel with the statistics of the training windows. Electrode
+positions are in metres, in `chs_info` or `pos`.
+
+```python
+import torch
+from braindecode.models import CORTEG
+
+model = CORTEG.from_pretrained(
+    "braindecode/{HUB_REPO}", chs_info=raw.info["chs"]
+).eval()
+flexion = model(x, x_hi)  # x: (batch, n_chans, 128), x_hi: (batch, n_chans, 200)
+```
+
+The output, `(batch, 5)`, is the flexion of each finger, z-scored per finger
+with the training statistics of the patient, at the time 40 ms before the
+window's end. The saved geometry is {report["n_chans"]} channels; the model
+reads any montage, so pass your own `chs_info` (or `n_chans` and `pos` at each
+call) when loading.
+
+## Limitations
+
+The readout is at its random initialization, as released: the paper run built
+it after the optimizer, so it was never trained, and the adapter learned around
+it (see the release manifest, `checkpoints/corteg_stanford_pooled.json`).
+The model was trained on the training split of the 9 Stanford patients (the
+first 400 s of each recording, two thirds of one under 600 s); other patients
+or tasks need fine-tuning, as in the paper's leave-one-subject-out protocol. The check above covers float32 CPU outputs, not
+decoding accuracy, GPU kernels or mixed precision; the authors report that this
+checkpoint reproduces the cohort mean of 0.554 (manifest, `paper.verified`).
+
+## Citation
+
+```bibtex
+@inproceedings{{yang2026corteg,
+  title     = {{{{CORTEG}}: Foundation Models Enable Cross-Modality Representation Transfer
+               from Scalp to Intracranial Brain Recordings}},
+  author    = {{Yang, Liuyin and Sun, Qiang and Van Dyck, Bob and Calvo Merino, Eva and
+               Van Hulle, Marc M.}},
+  booktitle = {{Advances in Neural Information Processing Systems (NeurIPS)}},
+  year      = {{2026}}
+}}
+```
+
+## License
+
+The adapter and the ST-EEGFormer backbone are both released by Liuyin Yang
+under the MIT licence (`LICENSE`). Braindecode's code is BSD-3-Clause.
+"""
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--reference-dir", type=Path, required=True)
+    parser.add_argument("--backbone", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--push-to", help="Hub namespace to publish the model to")
+    args = parser.parse_args()
+    torch.set_num_threads(1)
+    adapter_path = args.reference_dir / ADAPTER
+    for path, expected in ((adapter_path, ADAPTER_SHA256), (args.backbone, BACKBONE_SHA256)):
+        if sha256(path) != expected:
+            raise SystemExit(f"{path} is not the released file (sha256 mismatch)")
+    adapter = torch.load(adapter_path, map_location="cpu", weights_only=True)
+    n_adapter = sum(t.numel() for t in adapter.values())
+    if n_adapter != ADAPTER_PARAMS:
+        raise SystemExit(f"adapter holds {n_adapter} parameters, not {ADAPTER_PARAMS}")
+
+    max_abs_diff, n_chans_checked = 0.0, []
+    for pos in montages():
+        n_chans = len(pos)
+        model = CORTEG(n_chans=n_chans, **CONFIG).eval()
+        convert(adapter, model)
+        g = torch.Generator().manual_seed(0)
+        x = torch.randn(4, n_chans, 128, generator=g)
+        x_hi = torch.randn(4, n_chans, 200, generator=g)
+        with torch.no_grad():
+            out = model(x, x_hi, pos=pos)
+        expected = reference_outputs(args.reference_dir, args.backbone, x, x_hi, pos)
+        max_abs_diff = max(max_abs_diff, (out - expected).abs().max().item())
+        n_chans_checked.append(n_chans)
+    if max_abs_diff > TOLERANCE:
+        raise SystemExit(f"outputs differ by {max_abs_diff:.2e} > {TOLERANCE}")
+
+    # Users pass their own montage when loading; the weights do not depend on it.
+    n_chans = n_chans_checked[0]
+    model = CORTEG(n_chans=n_chans, **CONFIG).eval()
+    convert(adapter, model)
+    report = {
+        "source": f"{REPOSITORY}@{REVISION}:{ADAPTER}",
+        "sha256": ADAPTER_SHA256,
+        "backbone": f"{BACKBONE_URL} via {BACKBONE_REPO}@{BACKBONE_REVISION}",
+        "backbone_sha256": BACKBONE_SHA256,
+        "adapter_tensors": len(adapter),
+        "adapter_params": n_adapter,
+        "lora_scale": LORA_SCALE,
+        "n_params": sum(t.numel() for t in model.state_dict().values()),
+        "max_abs_diff": max_abs_diff,
+        "n_chans_checked": n_chans_checked,
+        "n_chans": n_chans,
+        "n_times": CONFIG["n_times"],
+        "torch_version": torch.__version__,
+    }
+    print(json.dumps(report, indent=2))
+    destination = args.output_dir / HUB_REPO
+    destination.mkdir(parents=True, exist_ok=True)
+    model.save_pretrained(destination)
+    # The Hub rejects NaN and Infinity, which Python's json writes by default.
+    json.loads(
+        (destination / "config.json").read_text(),
+        parse_constant=lambda c: (_ for _ in ()).throw(ValueError(f"{c} in config.json")),
+    )
+    shutil.copyfile(Path(__file__).resolve(), destination / Path(__file__).name)
+    (destination / "LICENSE").write_text(LICENSE)
+    (destination / "report.json").write_text(json.dumps(report, indent=2))
+    # Written last: save_pretrained leaves a placeholder card behind.
+    (destination / "README.md").write_text(model_card(report))
+    if args.push_to:
+        repo_id = f"{args.push_to}/{HUB_REPO}"
+        api = HfApi()
+        api.create_repo(repo_id, exist_ok=True)
+        api.upload_folder(
+            folder_path=str(destination),
+            repo_id=repo_id,
+            commit_message="CORTEG Stanford pooled model, converted from the official release",
+        )
+        print(f"published https://huggingface.co/{repo_id}")
+
+
+if __name__ == "__main__":
+    main()

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01211bbda61d0691386c7544449d039d7a5c34537c2ddec543800eb5234af5cb
+size 101860424

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8372cf7c96a6e87f32932e9303fc169cdfdf911b8d31cb1dc4f0c6826729b32
+size 101901883

report.json

@@ -0,0 +1,18 @@
+{
+  "source": "https://github.com/LiuyinYang1101/CORTEG@caafb78fbebdd9448814f96d7e61083a3eb62663:checkpoints/corteg_stanford_pooled.pt",
+  "sha256": "77d63a214e0e0f2c790e90878a0ef6b525f6e24e1453fcd94e118c63ff7e8396",
+  "backbone": "https://github.com/LiuyinYang1101/STEEGFormer/releases/download/ST-EEGFormer-small/checkpoint-300.pth via braindecode/STEEGFormer-small@633c9c0d76c6e26459e1e0d1337c91858578f13d",
+  "backbone_sha256": "98d2848abdaea7a143d399c07f67f8782e07dd66e7c309ddb058c7158a8a8b02",
+  "adapter_tensors": 64,
+  "adapter_params": 297236,
+  "lora_scale": 4.0,
+  "n_params": 25461524,
+  "max_abs_diff": 1.4603137969970703e-06,
+  "n_chans_checked": [
+    8,
+    46
+  ],
+  "n_chans": 8,
+  "n_times": 128,
+  "torch_version": "2.15.0+cu132"
+}