Add files using upload-large-folder tool

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S002/data.py

@@ -0,0 +1,33 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+import numpy as np
+import torch
+@lru_cache(maxsize=8)
+def array(path):return np.load(path,mmap_mode='r',allow_pickle=False)
+class Dataset(torch.utils.data.Dataset):
+    def __init__(self,root,limit=None,cache=False):
+        self.root=Path(root)
+        self.rows=json.loads((self.root/'manifest.json').read_text())['samples']
+        if limit:self.rows=self.rows[:limit]
+        self.cached=None
+        if cache and self.rows:
+            from collections import defaultdict
+            groups=defaultdict(list)
+            for i,r in enumerate(self.rows):groups[r['path']].append((i,r['index']))
+            for name,indices in groups.items():
+                path=(self.root/name).resolve()
+                if not path.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+                source=np.load(path,mmap_mode='r',allow_pickle=False)
+                if self.cached is None:self.cached=torch.empty((len(self.rows),*source.shape[1:]),dtype=torch.float32)
+                dst,src=zip(*indices)
+                self.cached[list(dst)]=torch.as_tensor(source[list(src)]/100,dtype=torch.float32)
+    def __len__(self):return len(self.rows)
+    def __getitem__(self,i):
+        r=self.rows[i]
+        if self.cached is not None:return self.cached[i],r.get('label',-1),r['id']
+        p=(self.root/r['path']).resolve()
+        if not p.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+        # Division precedes float32 conversion, matching official FACED/TUEV collate.
+        x=np.asarray(array(str(p))[r['index']])/100
+        return torch.as_tensor(x,dtype=torch.float32),r.get('label',-1),r['id']

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S002/infer.py

@@ -0,0 +1,24 @@
+import argparse,json
+from pathlib import Path
+import numpy as np
+import torch
+from model import SharedSpectral,SPECS
+from data import Dataset
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('input',type=Path);ap.add_argument('output',type=Path);a=ap.parse_args()
+    root=Path(__file__).resolve().parent
+    cfg=json.loads((root/'config.json').read_text())
+    track=json.loads((a.input/'manifest.json').read_text())['track']
+    if track not in SPECS: raise ValueError('Unknown track')
+    torch.set_num_threads(4)
+    device='cuda' if torch.cuda.is_available() else 'cpu'
+    model=SharedSpectral(**cfg['architecture']).to(device)
+    model.load_state_dict(torch.load(root/'weights.pt',map_location=device,weights_only=True),strict=True)
+    model.eval();a.output.mkdir(parents=True,exist_ok=True)
+    loader=torch.utils.data.DataLoader(Dataset(a.input),batch_size=128,num_workers=0,shuffle=False)
+    with torch.inference_mode(),(a.output/'predictions.jsonl').open('w') as f:
+        for x,_,ids in loader:
+            p=model(track,x.to(device)).softmax(-1).cpu().numpy()
+            for sid,pp in zip(ids,p):f.write(json.dumps({'id':sid,'probabilities':pp.tolist()})+'\n')
+if __name__=='__main__':main()

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S002/training.json

@@ -0,0 +1,844 @@
+{
+  "settings": {
+    "output": "/workspace/research/runs/spectral1",
+    "seed": 42,
+    "epochs": 30,
+    "steps": 500,
+    "batch_size": 128,
+    "lr": 0.0005,
+    "width": 256,
+    "depth": 3,
+    "dropout": 0.35,
+    "weight_decay": 0.05,
+    "mixup": 0.0,
+    "init": null
+  },
+  "shared_backbone": "backbone",
+  "all_tracks_update_shared_backbone": true,
+  "normalization_fit_split": "train",
+  "parameters": 14112534,
+  "history": [
+    {
+      "epoch": 1,
+      "updates_by_track": 100,
+      "losses": {
+        "faced": 1.837755205631256,
+        "tuev": 0.4842070505023003,
+        "ad65": 0.21590098470449448,
+        "openbmi": 0.5858061927556991,
+        "longitudinal": 0.42181126683950426
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            257,
+            245,
+            165,
+            195,
+            119,
+            133,
+            193,
+            53,
+            320
+          ],
+          "confusion_matrix": [
+            [
+              48,
+              17,
+              14,
+              22,
+              14,
+              11,
+              25,
+              5,
+              24
+            ],
+            [
+              18,
+              62,
+              10,
+              24,
+              12,
+              9,
+              18,
+              4,
+              23
+            ],
+            [
+              28,
+              19,
+              32,
+              12,
+              11,
+              19,
+              27,
+              4,
+              28
+            ],
+            [
+              22,
+              24,
+              23,
+              36,
+              15,
+              4,
+              16,
+              8,
+              32
+            ],
+            [
+              38,
+              38,
+              25,
+              45,
+              20,
+              15,
+              17,
+              2,
+              40
+            ],
+            [
+              18,
+              15,
+              17,
+              15,
+              12,
+              34,
+              20,
+              13,
+              36
+            ],
+            [
+              26,
+              25,
+              18,
+              16,
+              14,
+              14,
+              34,
+              3,
+              30
+            ],
+            [
+              22,
+              27,
+              11,
+              23,
+              11,
+              19,
+              22,
+              11,
+              34
+            ],
+            [
+              37,
+              18,
+              15,
+              2,
+              10,
+              8,
+              14,
+              3,
+              73
+            ]
+          ],
+          "per_class_recall": [
+            0.26666666666666666,
+            0.34444444444444444,
+            0.17777777777777778,
+            0.2,
+            0.08333333333333333,
+            0.18888888888888888,
+            0.18888888888888888,
+            0.06111111111111111,
+            0.40555555555555556
+          ],
+          "balanced_accuracy": 0.21296296296296294,
+          "accuracy": 0.20833333333333334,
+          "weighted_f1": 0.19537403895666947,
+          "macro_f1": 0.19848342511012498,
+          "kappa": 0.11081397292328254,
+          "samples": 1680,
+          "reward": 0.21296296296296294,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            224,
+            539,
+            102,
+            356,
+            2505,
+            11761
+          ],
+          "confusion_matrix": [
+            [
+              19,
+              29,
+              26,
+              0,
+              9,
+              36
+            ],
+            [
+              0,
+              12,
+              0,
+              0,
+              279,
+              0
+            ],
+            [
+              7,
+              65,
+              10,
+              0,
+              581,
+              6
+            ],
+            [
+              0,
+              36,
+              0,
+              35,
+              0,
+              15
+            ],
+            [
+              0,
+              1,
+              0,
+              1,
+              468,
+              30
+            ],
+            [
+              198,
+              396,
+              66,
+              320,
+              1168,
+              11674
+            ]
+          ],
+          "per_class_recall": [
+            0.15966386554621848,
+            0.041237113402061855,
+            0.014947683109118086,
+            0.4069767441860465,
+            0.936,
+            0.8445955722760816
+          ],
+          "balanced_accuracy": 0.4005701630865877,
+          "accuracy": 0.7889197391360496,
+          "weighted_f1": 0.8279708978381558,
+          "macro_f1": 0.2580220626735159,
+          "kappa": 0.3316723247964325,
+          "samples": 15487,
+          "reward": 0.4005701630865877,
+          "subjects": 58
+        },
+        "ad65": {
+          "class_counts": [
+            464,
+            393,
+            486
+          ],
+          "predicted_class_counts": [
+            544,
+            346,
+            453
+          ],
+          "confusion_matrix": [
+            [
+              274,
+              145,
+              45
+            ],
+            [
+              145,
+              172,
+              76
+            ],
+            [
+              125,
+              29,
+              332
+            ]
+          ],
+          "per_class_recall": [
+            0.5905172413793104,
+            0.43765903307888043,
+            0.6831275720164609
+          ],
+          "balanced_accuracy": 0.5704346154915506,
+          "accuracy": 0.5793000744601638,
+          "weighted_f1": 0.5799410326020693,
+          "macro_f1": 0.5720933182023854,
+          "kappa": 0.3650766423143895,
+          "samples": 1343,
+          "subject_metrics": {
+            "class_counts": [
+              7,
+              5,
+              6
+            ],
+            "predicted_class_counts": [
+              8,
+              5,
+              5
+            ],
+            "confusion_matrix": [
+              [
+                4,
+                3,
+                0
+              ],
+              [
+                2,
+                2,
+                1
+              ],
+              [
+                2,
+                0,
+                4
+              ]
+            ],
+            "per_class_recall": [
+              0.5714285714285714,
+              0.4,
+              0.6666666666666666
+            ],
+            "balanced_accuracy": 0.546031746031746,
+            "accuracy": 0.5555555555555556,
+            "weighted_f1": 0.560942760942761,
+            "macro_f1": 0.5535353535353535,
+            "kappa": 0.3239436619718309
+          },
+          "reward": 0.546031746031746,
+          "subjects": 18
+        },
+        "openbmi": {
+          "class_counts": [
+            2200,
+            2200
+          ],
+          "predicted_class_counts": [
+            1443,
+            2957
+          ],
+          "confusion_matrix": [
+            [
+              964,
+              1236
+            ],
+            [
+              479,
+              1721
+            ]
+          ],
+          "per_class_recall": [
+            0.4381818181818182,
+            0.7822727272727272
+          ],
+          "balanced_accuracy": 0.6102272727272727,
+          "accuracy": 0.6102272727272727,
+          "weighted_f1": 0.5983382295509261,
+          "macro_f1": 0.5983382295509261,
+          "kappa": 0.22045454545454546,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.6950000000000001,
+            "35": 0.545,
+            "34": 0.5349999999999999,
+            "51": 0.6675,
+            "20": 0.6525,
+            "44": 0.7375,
+            "24": 0.5549999999999999,
+            "15": 0.5325,
+            "31": 0.68,
+            "26": 0.5525,
+            "23": 0.56
+          },
+          "reward": 0.6102272727272727,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4602,
+            3816
+          ],
+          "confusion_matrix": [
+            [
+              3652,
+              608
+            ],
+            [
+              950,
+              3208
+            ]
+          ],
+          "per_class_recall": [
+            0.8572769953051643,
+            0.7715247715247715
+          ],
+          "balanced_accuracy": 0.8144008834149679,
+          "accuracy": 0.814920408648135,
+          "weighted_f1": 0.8145227049484558,
+          "macro_f1": 0.814404091564341,
+          "kappa": 0.6294215557528924,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8322374249306739,
+            "sub-G2007": 0.7939135582111965,
+            "sub-G2019": 0.8546280166979509,
+            "sub-G2031": 0.7822427227936398,
+            "sub-G2015": 0.8509791437797529,
+            "sub-CTR002": 0.8928359222476869,
+            "sub-G2011": 0.7801365675763949,
+            "sub-G2035": 0.9022323249571733,
+            "sub-CTR003": 0.46374458874458874
+          },
+          "reward": 0.7947722522154508,
+          "subjects": 9
+        }
+      },
+      "seconds": 8.115101099014282
+    },
+    {
+      "epoch": 2,
+      "updates_by_track": 200,
+      "losses": {
+        "faced": 1.3197942888736724,
+        "tuev": 0.35953703671693804,
+        "ad65": 0.17408071279525758,
+        "openbmi": 0.4457417243719101,
+        "longitudinal": 0.32790970653295515
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            175,
+            179,
+            184,
+            261,
+            229,
+            121,
+            161,
+            124,
+            246
+          ],
+          "confusion_matrix": [
+            [
+              30,
+              12,
+              14,
+              28,
+              25,
+              8,
+              27,
+              8,
+              28
+            ],
+            [
+              9,
+              57,
+              9,
+              28,
+              28,
+              5,
+              18,
+              13,
+              13
+            ],
+            [
+              24,
+              15,
+              34,
+              26,
+              13,
+              16,
+              15,
+              12,
+              25
+            ],
+            [
+              12,
+              15,
+              29,
+              44,
+              29,
+              2,
+              14,
+              12,
+              23
+            ],
+            [
+              15,
+              25,
+              28,
+              49,
+              50,
+              15,
+              16,
+              12,
+              30
+            ],
+            [
+              15,
+              7,
+              20,
+              17,
+              22,
+              43,
+              12,
+              20,
+              24
+            ],
+            [
+              26,
+              15,
+              15,
+              28,
+              20,
+              11,
+              32,
+              15,
+              18
+            ],
+            [
+              19,
+              22,
+              18,
+              25,
+              25,
+              15,
+              15,
+              19,
+              22
+            ],
+            [
+              25,
+              11,
+              17,
+              16,
+              17,
+              6,
+              12,
+              13,
+              63
+            ]
+          ],
+          "per_class_recall": [
+            0.16666666666666666,
+            0.31666666666666665,
+            0.18888888888888888,
+            0.24444444444444444,
+            0.20833333333333334,
+            0.2388888888888889,
+            0.17777777777777778,
+            0.10555555555555556,
+            0.35
+          ],
+          "balanced_accuracy": 0.22191358024691357,
+          "accuracy": 0.22142857142857142,
+          "weighted_f1": 0.21979152243904798,
+          "macro_f1": 0.22003492637365382,
+          "kappa": 0.12321945847597604,
+          "samples": 1680,
+          "reward": 0.22191358024691357,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            113,
+            573,
+            83,
+            202,
+            2202,
+            12314
+          ],
+          "confusion_matrix": [
+            [
+              0,
+              37,
+              27,
+              0,
+              22,
+              33
+            ],
+            [
+              0,
+              12,
+              0,
+              0,
+              279,
+              0
+            ],
+            [
+              3,
+              104,
+              12,
+              0,
+              527,
+              23
+            ],
+            [
+              0,
+              24,
+              0,
+              51,
+              0,
+              11
+            ],
+            [
+              0,
+              0,
+              0,
+              1,
+              468,
+              31
+            ],
+            [
+              110,
+              396,
+              44,
+              150,
+              906,
+              12216
+            ]
+          ],
+          "per_class_recall": [
+            0.0,
+            0.041237113402061855,
+            0.017937219730941704,
+            0.5930232558139535,
+            0.936,
+            0.8838084213572566
+          ],
+          "balanced_accuracy": 0.412001001717369,
+          "accuracy": 0.8238522631884807,
+          "weighted_f1": 0.849353580581419,
+          "macro_f1": 0.2825119959741656,
+          "kappa": 0.38132710505585,
+          "samples": 15487,
+          "reward": 0.412001001717369,
+          "subjects": 58
+        },
+        "ad65": {
+          "class_counts": [
+            464,
+            393,
+            486
+          ],
+          "predicted_class_counts": [
+            536,
+            352,
+            455
+          ],
+          "confusion_matrix": [
+            [
+              279,
+              150,
+              35
+            ],
+            [
+              152,
+              170,
+              71
+            ],
+            [
+              105,
+              32,
+              349
+            ]
+          ],
+          "per_class_recall": [
+            0.6012931034482759,
+            0.43256997455470736,
+            0.7181069958847737
+          ],
+          "balanced_accuracy": 0.5839900246292523,
+          "accuracy": 0.5941921072226359,
+          "weighted_f1": 0.5947617631793346,
+          "macro_f1": 0.5853799732304393,
+          "kappa": 0.38774750539323577,
+          "samples": 1343,
+          "subject_metrics": {
+            "class_counts": [
+              7,
+              5,
+              6
+            ],
+            "predicted_class_counts": [
+              6,
+              6,
+              6
+            ],
+            "confusion_matrix": [
+              [
+                3,
+                4,
+                0
+              ],
+              [
+                2,
+                2,
+                1
+              ],
+              [
+                1,
+                0,
+                5
+              ]
+            ],
+            "per_class_recall": [
+              0.42857142857142855,
+              0.4,
+              0.8333333333333334
+            ],
+            "balanced_accuracy": 0.5539682539682539,
+            "accuracy": 0.5555555555555556,
+            "weighted_f1": 0.5582750582750583,
+            "macro_f1": 0.5528360528360529,
+            "kappa": 0.33333333333333337
+          },
+          "reward": 0.5539682539682539,
+          "subjects": 18
+        },
+        "openbmi": {
+          "class_counts": [
+            2200,
+            2200
+          ],
+          "predicted_class_counts": [
+            2332,
+            2068
+          ],
+          "confusion_matrix": [
+            [
+              1461,
+              739
+            ],
+            [
+              871,
+              1329
+            ]
+          ],
+          "per_class_recall": [
+            0.6640909090909091,
+            0.6040909090909091
+          ],
+          "balanced_accuracy": 0.634090909090909,
+          "accuracy": 0.634090909090909,
+          "weighted_f1": 0.6337612942557392,
+          "macro_f1": 0.6337612942557392,
+          "kappa": 0.2681818181818182,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.7124999999999999,
+            "35": 0.55,
+            "34": 0.5425,
+            "51": 0.6525,
+            "20": 0.6875,
+            "44": 0.865,
+            "24": 0.57,
+            "15": 0.52,
+            "31": 0.685,
+            "26": 0.54,
+            "23": 0.65
+          },
+          "reward": 0.6340909090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4743,
+            3675
+          ],
+          "confusion_matrix": [
+            [
+              3660,
+              600
+            ],
+            [
+              1083,
+              3075
+            ]
+          ],
+          "per_class_recall": [
+            0.8591549295774648,
+            0.7395382395382395
+          ],
+          "balanced_accuracy": 0.7993465845578521,
+          "accuracy": 0.800071275837491,
+          "weighted_f1": 0.7992702199536446,
+          "macro_f1": 0.7991010528725839,
+          "kappa": 0.5995269115485379,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8247760032614722,
+            "sub-G2007": 0.6755647147391388,
+            "sub-G2019": 0.817720267605105,
+            "sub-G2031": 0.7768687400624462,
+            "sub-G2015": 0.887980417124405,
+            "sub-CTR002": 0.9382480264833206,
+            "sub-G2011": 0.7719037383413225,
+            "sub-G2035": 0.926835468058191,
+            "sub-CTR003": 0.5305735930735931
+          },
+          "reward": 0.7944967743054439,
+          "subjects": 9
+        }
+      },
+      "seconds": 9.67720913887024
+    }
+  ]
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S010/covariances.py

@@ -0,0 +1,25 @@
+"""Shared neural filter-bank covariance decoder with spatial input adapters."""
+import torch
+from torch import nn
+SPECS={'faced':(32,10,9),'tuev':(16,5,6),'ad65':(19,10,3),'openbmi':(62,4,2),'longitudinal':(58,2,2)}
+TRACKS=tuple(SPECS)
+BANDS=[(1,4),(4,8),(8,12),(12,16),(16,20),(20,24),(24,28),(28,32),(32,40),(40,48)]
+
+@torch.no_grad()
+def extract_covariances(t,x):
+    x=torch.nan_to_num(x.float().flatten(2)).clamp(-1e5,1e5)
+    x=x-x.mean(-1,keepdim=True)
+    if t in ('faced','tuev'):
+        x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+    else:x=x-x.mean(1,keepdim=True)
+    # Per-window normalization, preserving spatial and frequency power ratios.
+    x=x/x.square().mean((1,2),keepdim=True).clamp_min(1e-12).sqrt()
+    frames=x.unfold(-1,400,200);frames=frames-frames.mean(-1,keepdim=True)
+    z=torch.fft.rfft(frames*torch.hann_window(400,device=x.device),dim=-1)/200
+    covs=[]
+    for lo,hi in BANDS:
+        v=z[...,2*lo:2*hi].flatten(2)
+        cov=(v.real@v.real.transpose(-1,-2)+v.imag@v.imag.transpose(-1,-2))/v.shape[-1]
+        covs.append(cov)
+    return torch.stack(covs,1)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S010/data.py

@@ -0,0 +1,33 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+import numpy as np
+import torch
+@lru_cache(maxsize=8)
+def array(path):return np.load(path,mmap_mode='r',allow_pickle=False)
+class Dataset(torch.utils.data.Dataset):
+    def __init__(self,root,limit=None,cache=False):
+        self.root=Path(root)
+        self.rows=json.loads((self.root/'manifest.json').read_text())['samples']
+        if limit:self.rows=self.rows[:limit]
+        self.cached=None
+        if cache and self.rows:
+            from collections import defaultdict
+            groups=defaultdict(list)
+            for i,r in enumerate(self.rows):groups[r['path']].append((i,r['index']))
+            for name,indices in groups.items():
+                path=(self.root/name).resolve()
+                if not path.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+                source=np.load(path,mmap_mode='r',allow_pickle=False)
+                if self.cached is None:self.cached=torch.empty((len(self.rows),*source.shape[1:]),dtype=torch.float32)
+                dst,src=zip(*indices)
+                self.cached[list(dst)]=torch.as_tensor(source[list(src)]/100,dtype=torch.float32)
+    def __len__(self):return len(self.rows)
+    def __getitem__(self,i):
+        r=self.rows[i]
+        if self.cached is not None:return self.cached[i],r.get('label',-1),r['id']
+        p=(self.root/r['path']).resolve()
+        if not p.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+        # Division precedes float32 conversion, matching official FACED/TUEV collate.
+        x=np.asarray(array(str(p))[r['index']])/100
+        return torch.as_tensor(x,dtype=torch.float32),r.get('label',-1),r['id']

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S010/features.py

@@ -0,0 +1,63 @@
+"""One shared residual backbone, five linear input adapters and output heads."""
+import torch
+from torch import nn
+
+SPECS = {'faced': (32, 10, 9), 'tuev': (16, 5, 6), 'ad65': (19, 10, 3),
+         'openbmi': (62, 4, 2), 'longitudinal': (58, 2, 2)}
+TRACKS = tuple(SPECS)
+EDGES = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,18,20,22,25,28,32,36,40,45,50,60,70,80,95]
+COV_BANDS = [(1,4),(4,8),(8,12),(12,16),(16,20),(20,28),(28,40)]
+
+def feature_dim(channels):
+    return channels * (4*(len(EDGES)-1)+4) + len(COV_BANDS)*channels*(channels-1)//2
+
+@torch.no_grad()
+def extract_features(track, x):
+    """Fixed features; no batch statistics or fitted inference transformations."""
+    x = x.float().flatten(2)
+    x = torch.nan_to_num(x, nan=0., posinf=1e5, neginf=-1e5).clamp(-1e5,1e5)
+    x = x - x.mean(-1,keepdim=True)
+    if track in ('ad65','openbmi','longitudinal'):
+        x = x - x.mean(1,keepdim=True)
+    rms = x.square().mean(-1).clamp_min(1e-12).sqrt()
+    norm = x / rms.unsqueeze(-1)
+    moments = torch.stack([rms.log(), norm.abs().amax(-1).clamp_min(1).log(),
+                          norm.pow(4).mean(-1).clamp_min(1).log(),
+                          (norm[...,1:]-norm[...,:-1]).square().mean(-1).clamp_min(1e-10).log()],-1)
+    frames = x.unfold(-1,400,200)
+    frames = frames - frames.mean(-1,keepdim=True)
+    window = torch.hann_window(400,device=x.device)
+    z = torch.fft.rfft(frames*window,dim=-1)/200
+    power = z.abs().square()
+    bands = torch.stack([power[...,2*lo:2*hi].mean(-1) for lo,hi in zip(EDGES[:-1],EDGES[1:])],-1)
+    lp = bands.mean(-2).clamp_min(1e-12).log()
+    variation = bands.clamp_min(1e-12).log().std(-2,correction=0)
+    relative_frequency = lp - lp.mean(-1,keepdim=True)
+    relative_channel = lp - lp.mean(1,keepdim=True)
+    parts = [torch.cat([lp, relative_frequency, relative_channel, variation, moments],-1).flatten(1)]
+    ii,jj = torch.triu_indices(x.shape[1],x.shape[1],offset=1,device=x.device)
+    for lo,hi in COV_BANDS:
+        v = z[...,2*lo:2*hi].flatten(2)
+        cov = v.real @ v.real.transpose(-1,-2) + v.imag @ v.imag.transpose(-1,-2)
+        d = cov.diagonal(dim1=-2,dim2=-1).clamp_min(1e-12).sqrt()
+        cor = cov / (d.unsqueeze(1)*d.unsqueeze(2)).clamp_min(1e-12)
+        parts.append(cor[:,ii,jj].clamp(-1,1))
+    result = torch.cat(parts,-1)
+    return torch.nan_to_num(result).clamp(-40,40)
+
+class Standardize(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.register_buffer('mean',torch.zeros(dim))
+        self.register_buffer('scale',torch.ones(dim))
+    def forward(self,x):
+        return ((x-self.mean)/self.scale).clamp(-8,8)
+
+class Residual(nn.Module):
+    def __init__(self,width,dropout):
+        super().__init__()
+        self.net=nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width*2),nn.GELU(),
+                               nn.Dropout(dropout),nn.Linear(width*2,width),nn.Dropout(dropout))
+    def forward(self,x):
+        return x+self.net(x)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S010/infer.py

@@ -0,0 +1,24 @@
+import argparse,json
+from pathlib import Path
+import torch
+from model import HybridModel,SPECS
+from data import Dataset
+from covariances import extract_covariances
+p=argparse.ArgumentParser();p.add_argument('input',type=Path);p.add_argument('output',type=Path);a=p.parse_args()
+root=Path(__file__).resolve().parent;c=json.loads((root/'config.json').read_text());t=json.loads((a.input/'manifest.json').read_text())['track']
+if t not in SPECS:raise ValueError('unknown track')
+torch.set_num_threads(4);device='cuda' if torch.cuda.is_available() else 'cpu'
+m=HybridModel(**c['architecture']).to(device);m.load_state_dict(torch.load(root/'weights.pt',map_location=device,weights_only=True));m.eval()
+a.output.mkdir(parents=True,exist_ok=True)
+with torch.inference_mode(),(a.output/'predictions.jsonl').open('w') as f:
+    for x,_,ids in torch.utils.data.DataLoader(Dataset(a.input),batch_size=64,num_workers=0):
+        # FFT features stay float32; convolutions can use bfloat16 on CUDA.
+        x=x.to(device)
+        from features import extract_features
+        torch.backends.cuda.matmul.allow_tf32=False
+        features=extract_features(t,x)
+        covariances=extract_covariances(t,x)
+        torch.backends.cuda.matmul.allow_tf32=True
+        with torch.autocast(device,dtype=torch.bfloat16,enabled=device=='cuda'):pred=m(t,x,features,covariances=covariances)
+        pp=pred.float().softmax(-1).cpu().numpy()
+        for sid,pr in zip(ids,pp):f.write(json.dumps({'id':sid,'probabilities':pr.tolist()})+'\n')

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S010/infer.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec python "$(dirname -- "$0")/infer.py" "$1" "$2"

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S010/model.py

@@ -0,0 +1,103 @@
+"""One fused waveform/spectral backbone used identically by all five tasks."""
+import torch
+from torch import nn
+from braindecode.models import BIOT
+from features import SPECS,TRACKS,feature_dim,extract_features,Standardize,Residual
+from covariances import BANDS,extract_covariances
+
+class InputAdapter(nn.Module):
+    def __init__(self,c,width,channels,spectral_enabled=True):
+        super().__init__()
+        self.signal=nn.Conv1d(c,channels,1,bias=False)
+        self.neural=nn.Conv1d(c,18,1,bias=False)
+        self.normalizer=Standardize(feature_dim(c))
+        self.spectral=nn.Linear(feature_dim(c),width)
+        self.dropout=nn.Dropout(.1)
+        self.register_buffer("spectral_enabled",torch.tensor(float(spectral_enabled)))
+        self.spatial_weight=nn.Parameter(torch.randn(len(BANDS),24,c)/c**.5)
+    def spatial_features(self,covariances):
+        with torch.autocast(covariances.device.type,enabled=False):
+            w=self.spatial_weight.float()/self.spatial_weight.float().norm(dim=-1,keepdim=True).clamp_min(1e-6)
+            power=torch.einsum('bfc,nbcd,bfd->nbf',w,covariances.float(),w).clamp_min(1e-8).log()
+            return torch.cat([power,power-power.mean(1,keepdim=True)],1).flatten(1)
+    def forward(self,x,features,covariance_features):
+        return self.signal(x).unsqueeze(1),self.spectral_enabled*self.spectral(self.dropout(self.normalizer(features))),self.neural(x),covariance_features
+
+class SharedBackbone(nn.Module):
+    def __init__(self,channels,width,depth,dropout,wave_filters):
+        super().__init__()
+        self.waveform=nn.Sequential(
+            nn.Conv2d(1,wave_filters,(1,64),padding=(0,32),bias=False),nn.GroupNorm(1,wave_filters),
+            nn.Conv2d(wave_filters,2*wave_filters,(channels,1),groups=wave_filters,bias=False),nn.GroupNorm(1,2*wave_filters),nn.ELU(),
+            nn.AvgPool2d((1,4)),nn.Dropout(.35),
+            nn.Conv2d(2*wave_filters,2*wave_filters,(1,16),padding=(0,8),groups=2*wave_filters,bias=False),nn.Conv2d(2*wave_filters,2*wave_filters,1,bias=False),
+            nn.GroupNorm(1,2*wave_filters),nn.ELU(),nn.AvgPool2d((1,8)),nn.Dropout(.35))
+        self.wave_summary=nn.Sequential(nn.AdaptiveAvgPool2d((1,8)),nn.Flatten(),nn.Linear(2*wave_filters*8,width))
+        self.fusion=nn.Sequential(nn.LayerNorm(width),nn.GELU(),nn.Dropout(dropout),
+                                 *[Residual(width,dropout) for _ in range(depth)],nn.LayerNorm(width))
+        # Both representations interact before the shared residual stack.
+        self.wave_gain=nn.Parameter(torch.tensor(.1))
+        self.biot=BIOT(n_chans=18,n_outputs=2,n_times=400,sfreq=200)
+        self.biot.final_layer=nn.Identity()
+        self.biot_projection=nn.Sequential(nn.LayerNorm(256),nn.Linear(256,width),nn.Dropout(.2))
+        nn.init.normal_(self.biot_projection[1].weight,std=.001);nn.init.zeros_(self.biot_projection[1].bias)
+        self.covariance_encoder=nn.Sequential(nn.LayerNorm(len(BANDS)*24*2),nn.Linear(len(BANDS)*24*2,width),nn.GELU(),nn.Dropout(.4),
+                                             *[Residual(width,.4) for _ in range(2)],nn.LayerNorm(width))
+        self.covariance_projection=nn.Linear(width,width)
+        nn.init.zeros_(self.covariance_projection.weight);nn.init.zeros_(self.covariance_projection.bias)
+    def forward(self,signal,spectral,neural_signal,covariance_features):
+        wave=self.waveform(signal)
+        neural=self.biot(neural_signal.float())
+        neural=self.biot_projection[0](neural)
+        projected=self.biot_projection[2](self.biot_projection[1](neural))
+        with torch.autocast(signal.device.type,enabled=False):
+            covariance_embedding=self.covariance_encoder(covariance_features.float())
+        original=spectral+self.wave_gain*self.wave_summary(wave)+.01*projected
+        coupled=.001*self.covariance_projection(covariance_embedding).to(original.dtype)
+        fused=self.fusion(original+coupled)
+        return torch.cat([wave.flatten(1),fused,neural,covariance_embedding],-1)
+
+class HybridModel(nn.Module):
+    def __init__(self,channels=32,width=128,depth=2,dropout=.5,wave_filters=32):
+        super().__init__()
+        self.adapters=nn.ModuleDict({t:InputAdapter(c,width,channels,spectral_enabled=t not in ("faced","tuev","openbmi")) for t,(c,s,k) in SPECS.items()})
+        self.backbone=SharedBackbone(channels,width,depth,dropout,wave_filters)
+        self.heads=nn.ModuleDict({t:nn.Linear(2*wave_filters*(((s*200+1)//4+1)//8)+width+256+width,k) for t,(c,s,k) in SPECS.items()})
+    def forward(self,t,x,features=None,covariances=None,covariance_features=None):
+        if features is None:features=extract_features(t,x)
+        if covariance_features is None:
+            if covariances is None:covariances=extract_covariances(t,x)
+            covariance_features=self.adapters[t].spatial_features(covariances)
+        signal=x.flatten(2);signal=signal-signal.mean(-1,keepdim=True)
+        if t in ('faced','tuev'):signal=signal/signal.std(-1,keepdim=True,correction=0).clamp_min(1e-6)
+        else:signal=signal-signal.mean(1,keepdim=True)
+        signal=signal.clamp(-20,20)
+        adapted=self.adapters[t](signal,features,covariance_features)
+        representation=self.backbone(*adapted)
+        if t in ('faced','openbmi'):
+            representation=torch.cat([representation[:,:-384],torch.zeros_like(representation[:,-384:-128]),representation[:,-128:]],-1)
+        if t=='ad65':
+            with torch.autocast(x.device.type,enabled=False):return self.heads[t](representation.float())
+        # This is one linear head, evaluated in feature blocks so appending
+        # zero-weight columns preserves the prior bfloat16 GEMM dimensions.
+        head=self.heads[t]
+        prior=nn.functional.linear(representation[:,:-128].contiguous(),head.weight[:,:-128].contiguous(),head.bias)
+        added=nn.functional.linear(representation[:,-128:].contiguous(),head.weight[:,-128:].contiguous())
+        return prior+added
+
+def widen_state_dict(state,multiplier=2):
+    """Duplicate temporal features and divide downstream sums to preserve outputs."""
+    result={}
+    for key,value in state.items():
+        if key.startswith('backbone.waveform.'):
+            layer=int(key.split('.')[2])
+            if layer in (0,2,7):value=value.repeat(multiplier,1,1,1)
+            elif layer in (1,3,9):value=value.repeat(multiplier)
+            elif layer==8:value=value.repeat(multiplier,multiplier,1,1)/multiplier
+        elif key=='backbone.wave_summary.2.weight':value=value.repeat(1,multiplier)/multiplier
+        elif key.startswith('heads.') and key.endswith('.weight'):
+            raw=value[:,:-128]/multiplier
+            value=torch.cat([raw]*multiplier+[value[:,-128:]],1)
+        result[key]=value
+    return result
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S010/training.json

@@ -0,0 +1,2097 @@
+{
+  "settings": {
+    "source": "/workspace/research/runs/hybrid_biot_csp_bf16head/epoch-001",
+    "features": "/workspace/research/head_features_v1",
+    "incumbent": "/workspace/research/runs/head_refinement1/epoch-012",
+    "output": "/workspace/research/runs/head_dropout1",
+    "epochs": 30,
+    "steps": 200,
+    "batch_size": 256,
+    "lr": 1e-05,
+    "clinical_lr": 0.0001,
+    "retention": 2.0,
+    "dropout": 0.2,
+    "seed": 7
+  },
+  "history": [
+    {
+      "epoch": 14,
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            157,
+            194,
+            179,
+            214,
+            244,
+            162,
+            180,
+            173,
+            177
+          ],
+          "confusion_matrix": [
+            [
+              78,
+              14,
+              5,
+              23,
+              19,
+              9,
+              13,
+              9,
+              10
+            ],
+            [
+              11,
+              88,
+              9,
+              13,
+              19,
+              11,
+              13,
+              6,
+              10
+            ],
+            [
+              6,
+              7,
+              94,
+              20,
+              17,
+              5,
+              7,
+              10,
+              14
+            ],
+            [
+              14,
+              18,
+              9,
+              71,
+              21,
+              8,
+              16,
+              15,
+              8
+            ],
+            [
+              13,
+              13,
+              16,
+              26,
+              113,
+              17,
+              13,
+              18,
+              11
+            ],
+            [
+              6,
+              12,
+              12,
+              15,
+              12,
+              83,
+              10,
+              14,
+              16
+            ],
+            [
+              8,
+              12,
+              8,
+              14,
+              16,
+              14,
+              90,
+              9,
+              9
+            ],
+            [
+              8,
+              16,
+              15,
+              17,
+              15,
+              10,
+              10,
+              83,
+              6
+            ],
+            [
+              13,
+              14,
+              11,
+              15,
+              12,
+              5,
+              8,
+              9,
+              93
+            ]
+          ],
+          "per_class_recall": [
+            0.43333333333333335,
+            0.4888888888888889,
+            0.5222222222222223,
+            0.39444444444444443,
+            0.4708333333333333,
+            0.46111111111111114,
+            0.5,
+            0.46111111111111114,
+            0.5166666666666667
+          ],
+          "balanced_accuracy": 0.472067901234568,
+          "accuracy": 0.4720238095238095,
+          "weighted_f1": 0.4732298815998091,
+          "macro_f1": 0.47346276059386383,
+          "kappa": 0.40521122712903535,
+          "samples": 1680,
+          "reward": 0.472067901234568,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            995,
+            658,
+            146,
+            706,
+            1616,
+            11366
+          ],
+          "confusion_matrix": [
+            [
+              42,
+              38,
+              18,
+              4,
+              0,
+              17
+            ],
+            [
+              0,
+              185,
+              0,
+              78,
+              28,
+              0
+            ],
+            [
+              110,
+              127,
+              128,
+              61,
+              243,
+              0
+            ],
+            [
+              6,
+              0,
+              0,
+              79,
+              0,
+              1
+            ],
+            [
+              2,
+              0,
+              0,
+              25,
+              420,
+              53
+            ],
+            [
+              835,
+              308,
+              0,
+              459,
+              925,
+              11295
+            ]
+          ],
+          "per_class_recall": [
+            0.35294117647058826,
+            0.6357388316151202,
+            0.19133034379671152,
+            0.9186046511627907,
+            0.84,
+            0.8171755172912748
+          ],
+          "balanced_accuracy": 0.6259650867227476,
+          "accuracy": 0.7844643894879576,
+          "weighted_f1": 0.8358334233956254,
+          "macro_f1": 0.3787874146773398,
+          "kappa": 0.36546485724249755,
+          "samples": 15487,
+          "reward": 0.6259650867227476,
+          "subjects": 58
+        },
+        "ad65": {
+          "class_counts": [
+            464,
+            393,
+            486
+          ],
+          "predicted_class_counts": [
+            440,
+            309,
+            594
+          ],
+          "confusion_matrix": [
+            [
+              287,
+              86,
+              91
+            ],
+            [
+              96,
+              185,
+              112
+            ],
+            [
+              57,
+              38,
+              391
+            ]
+          ],
+          "per_class_recall": [
+            0.6185344827586207,
+            0.4707379134860051,
+            0.8045267489711934
+          ],
+          "balanced_accuracy": 0.6312663817386064,
+          "accuracy": 0.6425912137006702,
+          "weighted_f1": 0.6356338206725993,
+          "macro_f1": 0.6286984511173302,
+          "kappa": 0.4579978610488933,
+          "samples": 1343,
+          "subject_metrics": {
+            "class_counts": [
+              7,
+              5,
+              6
+            ],
+            "predicted_class_counts": [
+              5,
+              6,
+              7
+            ],
+            "confusion_matrix": [
+              [
+                5,
+                2,
+                0
+              ],
+              [
+                0,
+                4,
+                1
+              ],
+              [
+                0,
+                0,
+                6
+              ]
+            ],
+            "per_class_recall": [
+              0.7142857142857143,
+              0.8,
+              1.0
+            ],
+            "balanced_accuracy": 0.8380952380952381,
+            "accuracy": 0.8333333333333334,
+            "weighted_f1": 0.8337865837865839,
+            "macro_f1": 0.8278943278943279,
+            "kappa": 0.7511520737327189
+          },
+          "reward": 0.8380952380952381,
+          "subjects": 18
+        },
+        "openbmi": {
+          "class_counts": [
+            2200,
+            2200
+          ],
+          "predicted_class_counts": [
+            2040,
+            2360
+          ],
+          "confusion_matrix": [
+            [
+              1690,
+              510
+            ],
+            [
+              350,
+              1850
+            ]
+          ],
+          "per_class_recall": [
+            0.7681818181818182,
+            0.8409090909090909
+          ],
+          "balanced_accuracy": 0.8045454545454546,
+          "accuracy": 0.8045454545454546,
+          "weighted_f1": 0.8042866600463423,
+          "macro_f1": 0.8042866600463423,
+          "kappa": 0.6090909090909091,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.8574999999999999,
+            "35": 0.9525,
+            "34": 0.6475,
+            "51": 0.75,
+            "20": 0.815,
+            "44": 0.935,
+            "24": 0.595,
+            "15": 0.8975,
+            "31": 0.8825000000000001,
+            "26": 0.7925,
+            "23": 0.725
+          },
+          "reward": 0.8045454545454546,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4576,
+            3842
+          ],
+          "confusion_matrix": [
+            [
+              3659,
+              601
+            ],
+            [
+              917,
+              3241
+            ]
+          ],
+          "per_class_recall": [
+            0.8589201877934273,
+            0.7794612794612794
+          ],
+          "balanced_accuracy": 0.8191907336273534,
+          "accuracy": 0.819672131147541,
+          "weighted_f1": 0.8193351694632243,
+          "macro_f1": 0.8192264033499321,
+          "kappa": 0.6389628187072087,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.837643455629449,
+            "sub-G2007": 0.7651266214233094,
+            "sub-G2019": 0.8242345047591977,
+            "sub-G2031": 0.788678938415735,
+            "sub-G2015": 0.8446221994740171,
+            "sub-CTR002": 0.9869493251846193,
+            "sub-G2011": 0.765938925240826,
+            "sub-G2035": 0.9564871486872261,
+            "sub-CTR003": 0.5773809523809523
+          },
+          "reward": 0.8163402301328146,
+          "subjects": 9
+        }
+      },
+      "selected_head_epochs": {
+        "faced": 0,
+        "tuev": 0,
+        "ad65": 0,
+        "openbmi": 0,
+        "longitudinal": 14
+      }
+    },
+    {
+      "epoch": 16,
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            157,
+            194,
+            179,
+            214,
+            244,
+            162,
+            180,
+            173,
+            177
+          ],
+          "confusion_matrix": [
+            [
+              78,
+              14,
+              5,
+              23,
+              19,
+              9,
+              13,
+              9,
+              10
+            ],
+            [
+              11,
+              88,
+              9,
+              13,
+              19,
+              11,
+              13,
+              6,
+              10
+            ],
+            [
+              6,
+              7,
+              94,
+              20,
+              17,
+              5,
+              7,
+              10,
+              14
+            ],
+            [
+              14,
+              18,
+              9,
+              71,
+              21,
+              8,
+              16,
+              15,
+              8
+            ],
+            [
+              13,
+              13,
+              16,
+              26,
+              113,
+              17,
+              13,
+              18,
+              11
+            ],
+            [
+              6,
+              12,
+              12,
+              15,
+              12,
+              83,
+              10,
+              14,
+              16
+            ],
+            [
+              8,
+              12,
+              8,
+              14,
+              16,
+              14,
+              90,
+              9,
+              9
+            ],
+            [
+              8,
+              16,
+              15,
+              17,
+              15,
+              10,
+              10,
+              83,
+              6
+            ],
+            [
+              13,
+              14,
+              11,
+              15,
+              12,
+              5,
+              8,
+              9,
+              93
+            ]
+          ],
+          "per_class_recall": [
+            0.43333333333333335,
+            0.4888888888888889,
+            0.5222222222222223,
+            0.39444444444444443,
+            0.4708333333333333,
+            0.46111111111111114,
+            0.5,
+            0.46111111111111114,
+            0.5166666666666667
+          ],
+          "balanced_accuracy": 0.472067901234568,
+          "accuracy": 0.4720238095238095,
+          "weighted_f1": 0.4732298815998091,
+          "macro_f1": 0.47346276059386383,
+          "kappa": 0.40521122712903535,
+          "samples": 1680,
+          "reward": 0.472067901234568,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            995,
+            658,
+            146,
+            706,
+            1616,
+            11366
+          ],
+          "confusion_matrix": [
+            [
+              42,
+              38,
+              18,
+              4,
+              0,
+              17
+            ],
+            [
+              0,
+              185,
+              0,
+              78,
+              28,
+              0
+            ],
+            [
+              110,
+              127,
+              128,
+              61,
+              243,
+              0
+            ],
+            [
+              6,
+              0,
+              0,
+              79,
+              0,
+              1
+            ],
+            [
+              2,
+              0,
+              0,
+              25,
+              420,
+              53
+            ],
+            [
+              835,
+              308,
+              0,
+              459,
+              925,
+              11295
+            ]
+          ],
+          "per_class_recall": [
+            0.35294117647058826,
+            0.6357388316151202,
+            0.19133034379671152,
+            0.9186046511627907,
+            0.84,
+            0.8171755172912748
+          ],
+          "balanced_accuracy": 0.6259650867227476,
+          "accuracy": 0.7844643894879576,
+          "weighted_f1": 0.8358334233956254,
+          "macro_f1": 0.3787874146773398,
+          "kappa": 0.36546485724249755,
+          "samples": 15487,
+          "reward": 0.6259650867227476,
+          "subjects": 58
+        },
+        "ad65": {
+          "class_counts": [
+            464,
+            393,
+            486
+          ],
+          "predicted_class_counts": [
+            440,
+            309,
+            594
+          ],
+          "confusion_matrix": [
+            [
+              287,
+              86,
+              91
+            ],
+            [
+              96,
+              185,
+              112
+            ],
+            [
+              57,
+              38,
+              391
+            ]
+          ],
+          "per_class_recall": [
+            0.6185344827586207,
+            0.4707379134860051,
+            0.8045267489711934
+          ],
+          "balanced_accuracy": 0.6312663817386064,
+          "accuracy": 0.6425912137006702,
+          "weighted_f1": 0.6356338206725993,
+          "macro_f1": 0.6286984511173302,
+          "kappa": 0.4579978610488933,
+          "samples": 1343,
+          "subject_metrics": {
+            "class_counts": [
+              7,
+              5,
+              6
+            ],
+            "predicted_class_counts": [
+              5,
+              6,
+              7
+            ],
+            "confusion_matrix": [
+              [
+                5,
+                2,
+                0
+              ],
+              [
+                0,
+                4,
+                1
+              ],
+              [
+                0,
+                0,
+                6
+              ]
+            ],
+            "per_class_recall": [
+              0.7142857142857143,
+              0.8,
+              1.0
+            ],
+            "balanced_accuracy": 0.8380952380952381,
+            "accuracy": 0.8333333333333334,
+            "weighted_f1": 0.8337865837865839,
+            "macro_f1": 0.8278943278943279,
+            "kappa": 0.7511520737327189
+          },
+          "reward": 0.8380952380952381,
+          "subjects": 18
+        },
+        "openbmi": {
+          "class_counts": [
+            2200,
+            2200
+          ],
+          "predicted_class_counts": [
+            2040,
+            2360
+          ],
+          "confusion_matrix": [
+            [
+              1690,
+              510
+            ],
+            [
+              350,
+              1850
+            ]
+          ],
+          "per_class_recall": [
+            0.7681818181818182,
+            0.8409090909090909
+          ],
+          "balanced_accuracy": 0.8045454545454546,
+          "accuracy": 0.8045454545454546,
+          "weighted_f1": 0.8042866600463423,
+          "macro_f1": 0.8042866600463423,
+          "kappa": 0.6090909090909091,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.8574999999999999,
+            "35": 0.9525,
+            "34": 0.6475,
+            "51": 0.75,
+            "20": 0.815,
+            "44": 0.935,
+            "24": 0.595,
+            "15": 0.8975,
+            "31": 0.8825000000000001,
+            "26": 0.7925,
+            "23": 0.725
+          },
+          "reward": 0.8045454545454546,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4574,
+            3844
+          ],
+          "confusion_matrix": [
+            [
+              3658,
+              602
+            ],
+            [
+              916,
+              3242
+            ]
+          ],
+          "per_class_recall": [
+            0.8586854460093897,
+            0.7797017797017797
+          ],
+          "balanced_accuracy": 0.8191936128555847,
+          "accuracy": 0.819672131147541,
+          "weighted_f1": 0.8193389120476722,
+          "macro_f1": 0.819230668900581,
+          "kappa": 0.6389648996053923,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8368421735781668,
+            "sub-G2007": 0.7651266214233094,
+            "sub-G2019": 0.8242345047591977,
+            "sub-G2031": 0.788678938415735,
+            "sub-G2015": 0.8446221994740171,
+            "sub-CTR002": 0.9869493251846193,
+            "sub-G2011": 0.765938925240826,
+            "sub-G2035": 0.9573204820205594,
+            "sub-CTR003": 0.5773809523809523
+          },
+          "reward": 0.8163437913863759,
+          "subjects": 9
+        }
+      },
+      "selected_head_epochs": {
+        "faced": 0,
+        "tuev": 0,
+        "ad65": 0,
+        "openbmi": 0,
+        "longitudinal": 16
+      }
+    }
+  ],
+  "shared_backbone_training": "inherited joint training on all five training splits; frozen during final linear-head refinement",
+  "parent_training_receipt": {
+    "all_tracks_update_shared_backbone": true,
+    "parameters": 10427373,
+    "source_training_settings": {
+      "output": "/workspace/research/runs/hybrid_biot_csp_stable1",
+      "epochs": 30,
+      "steps": 100,
+      "batch_size": 64,
+      "seed": 7,
+      "hidden": 32,
+      "dropout": 0.5,
+      "lr": 1e-06,
+      "head_lr": 1e-07,
+      "weight_decay": 0.05,
+      "init": "/workspace/research/runs/hybrid_biot_fusionshrink0100/epoch-001/weights.pt",
+      "mixup": 0.0,
+      "clinical_lr": 0.0001,
+      "neural_lr": 1e-05,
+      "covariance_parent": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+      "ad_pool": 8
+    },
+    "parent_training_history": [
+      {
+        "epoch": 1,
+        "validation": {
+          "faced": {
+            "class_counts": [
+              180,
+              180,
+              180,
+              180,
+              240,
+              180,
+              180,
+              180,
+              180
+            ],
+            "predicted_class_counts": [
+              157,
+              190,
+              178,
+              212,
+              242,
+              166,
+              182,
+              175,
+              178
+            ],
+            "confusion_matrix": [
+              [
+                77,
+                14,
+                5,
+                22,
+                19,
+                9,
+                14,
+                10,
+                10
+              ],
+              [
+                12,
+                86,
+                9,
+                13,
+                19,
+                11,
+                14,
+                6,
+                10
+              ],
+              [
+                6,
+                7,
+                93,
+                20,
+                17,
+                5,
+                7,
+                10,
+                15
+              ],
+              [
+                14,
+                18,
+                9,
+                71,
+                21,
+                8,
+                16,
+                15,
+                8
+              ],
+              [
+                13,
+                13,
+                17,
+                26,
+                111,
+                17,
+                14,
+                18,
+                11
+              ],
+              [
+                6,
+                11,
+                11,
+                15,
+                11,
+                86,
+                10,
+                14,
+                16
+              ],
+              [
+                8,
+                11,
+                9,
+                13,
+                17,
+                14,
+                89,
+                10,
+                9
+              ],
+              [
+                8,
+                16,
+                14,
+                17,
+                15,
+                11,
+                10,
+                83,
+                6
+              ],
+              [
+                13,
+                14,
+                11,
+                15,
+                12,
+                5,
+                8,
+                9,
+                93
+              ]
+            ],
+            "per_class_recall": [
+              0.42777777777777776,
+              0.4777777777777778,
+              0.5166666666666667,
+              0.39444444444444443,
+              0.4625,
+              0.4777777777777778,
+              0.49444444444444446,
+              0.46111111111111114,
+              0.5166666666666667
+            ],
+            "balanced_accuracy": 0.46990740740740744,
+            "accuracy": 0.46964285714285714,
+            "weighted_f1": 0.4707562771324448,
+            "macro_f1": 0.471133142475755,
+            "kappa": 0.4025575937544903,
+            "samples": 1680,
+            "reward": 0.46990740740740744,
+            "subjects": 20
+          },
+          "tuev": {
+            "class_counts": [
+              119,
+              291,
+              669,
+              86,
+              500,
+              13822
+            ],
+            "predicted_class_counts": [
+              1415,
+              660,
+              126,
+              754,
+              1618,
+              10914
+            ],
+            "confusion_matrix": [
+              [
+                45,
+                38,
+                15,
+                0,
+                4,
+                17
+              ],
+              [
+                17,
+                164,
+                0,
+                61,
+                49,
+                0
+              ],
+              [
+                130,
+                126,
+                111,
+                89,
+                213,
+                0
+              ],
+              [
+                7,
+                2,
+                0,
+                76,
+                0,
+                1
+              ],
+              [
+                4,
+                0,
+                0,
+                24,
+                435,
+                37
+              ],
+              [
+                1212,
+                330,
+                0,
+                504,
+                917,
+                10859
+              ]
+            ],
+            "per_class_recall": [
+              0.37815126050420167,
+              0.563573883161512,
+              0.16591928251121077,
+              0.8837209302325582,
+              0.87,
+              0.7856316017942411
+            ],
+            "balanced_accuracy": 0.6078328263672873,
+            "accuracy": 0.7548266287854329,
+            "weighted_f1": 0.8168597460216521,
+            "macro_f1": 0.3587540627106629,
+            "kappa": 0.32929623559334475,
+            "samples": 15487,
+            "reward": 0.6078328263672873,
+            "subjects": 58
+          },
+          "ad65": {
+            "class_counts": [
+              464,
+              393,
+              486
+            ],
+            "predicted_class_counts": [
+              440,
+              309,
+              594
+            ],
+            "confusion_matrix": [
+              [
+                287,
+                86,
+                91
+              ],
+              [
+                96,
+                185,
+                112
+              ],
+              [
+                57,
+                38,
+                391
+              ]
+            ],
+            "per_class_recall": [
+              0.6185344827586207,
+              0.4707379134860051,
+              0.8045267489711934
+            ],
+            "balanced_accuracy": 0.6312663817386064,
+            "accuracy": 0.6425912137006702,
+            "weighted_f1": 0.6356338206725993,
+            "macro_f1": 0.6286984511173302,
+            "kappa": 0.4579978610488933,
+            "samples": 1343,
+            "subject_metrics": {
+              "class_counts": [
+                7,
+                5,
+                6
+              ],
+              "predicted_class_counts": [
+                5,
+                6,
+                7
+              ],
+              "confusion_matrix": [
+                [
+                  5,
+                  2,
+                  0
+                ],
+                [
+                  0,
+                  4,
+                  1
+                ],
+                [
+                  0,
+                  0,
+                  6
+                ]
+              ],
+              "per_class_recall": [
+                0.7142857142857143,
+                0.8,
+                1.0
+              ],
+              "balanced_accuracy": 0.8380952380952381,
+              "accuracy": 0.8333333333333334,
+              "weighted_f1": 0.8337865837865839,
+              "macro_f1": 0.8278943278943279,
+              "kappa": 0.7511520737327189
+            },
+            "reward": 0.8380952380952381,
+            "subjects": 18
+          },
+          "openbmi": {
+            "class_counts": [
+              2200,
+              2200
+            ],
+            "predicted_class_counts": [
+              2059,
+              2341
+            ],
+            "confusion_matrix": [
+              [
+                1696,
+                504
+              ],
+              [
+                363,
+                1837
+              ]
+            ],
+            "per_class_recall": [
+              0.7709090909090909,
+              0.835
+            ],
+            "balanced_accuracy": 0.8029545454545455,
+            "accuracy": 0.8029545454545455,
+            "weighted_f1": 0.8027519892716276,
+            "macro_f1": 0.8027519892716275,
+            "kappa": 0.605909090909091,
+            "samples": 4400,
+            "subject_scores": {
+              "19": 0.8425,
+              "35": 0.9525,
+              "34": 0.64,
+              "51": 0.7475,
+              "20": 0.82,
+              "44": 0.94,
+              "24": 0.5974999999999999,
+              "15": 0.9,
+              "31": 0.8825000000000001,
+              "26": 0.79,
+              "23": 0.72
+            },
+            "reward": 0.8029545454545456,
+            "subjects": 11
+          },
+          "longitudinal": {
+            "class_counts": [
+              4260,
+              4158
+            ],
+            "predicted_class_counts": [
+              4572,
+              3846
+            ],
+            "confusion_matrix": [
+              [
+                3656,
+                604
+              ],
+              [
+                916,
+                3242
+              ]
+            ],
+            "per_class_recall": [
+              0.8582159624413146,
+              0.7797017797017797
+            ],
+            "balanced_accuracy": 0.8189588710715472,
+            "accuracy": 0.8194345450225707,
+            "weighted_f1": 0.8191046137658184,
+            "macro_f1": 0.8189967516241878,
+            "kappa": 0.6384913111521573,
+            "samples": 8418,
+            "subject_scores": {
+              "sub-G2021": 0.837643455629449,
+              "sub-G2007": 0.7644167136410334,
+              "sub-G2019": 0.8242345047591977,
+              "sub-G2031": 0.788678938415735,
+              "sub-G2015": 0.8429774626319118,
+              "sub-CTR002": 0.9869493251846193,
+              "sub-G2011": 0.765938925240826,
+              "sub-G2035": 0.9564871486872261,
+              "sub-CTR003": 0.5773809523809523
+            },
+            "reward": 0.8160786029523278,
+            "subjects": 9
+          }
+        },
+        "losses": {
+          "faced": 1.1245228350162506,
+          "tuev": 0.8237144947052002,
+          "ad65": 0.5528117254376411,
+          "openbmi": 0.41377417743206024,
+          "longitudinal": 0.23846278339624405
+        },
+        "seconds": 33.64874625205994
+      }
+    ],
+    "history": [
+      {
+        "epoch": 1,
+        "validation": {
+          "faced": {
+            "class_counts": [
+              180,
+              180,
+              180,
+              180,
+              240,
+              180,
+              180,
+              180,
+              180
+            ],
+            "predicted_class_counts": [
+              158,
+              189,
+              178,
+              213,
+              242,
+              166,
+              182,
+              176,
+              176
+            ],
+            "confusion_matrix": [
+              [
+                77,
+                14,
+                5,
+                22,
+                19,
+                9,
+                14,
+                10,
+                10
+              ],
+              [
+                12,
+                86,
+                9,
+                13,
+                19,
+                11,
+                14,
+                6,
+                10
+              ],
+              [
+                6,
+                7,
+                93,
+                21,
+                17,
+                5,
+                7,
+                10,
+                14
+              ],
+              [
+                14,
+                18,
+                9,
+                71,
+                21,
+                8,
+                16,
+                15,
+                8
+              ],
+              [
+                13,
+                13,
+                17,
+                26,
+                111,
+                17,
+                14,
+                18,
+                11
+              ],
+              [
+                6,
+                11,
+                11,
+                15,
+                11,
+                86,
+                10,
+                14,
+                16
+              ],
+              [
+                8,
+                11,
+                9,
+                13,
+                17,
+                14,
+                89,
+                10,
+                9
+              ],
+              [
+                8,
+                16,
+                14,
+                17,
+                15,
+                11,
+                10,
+                84,
+                5
+              ],
+              [
+                14,
+                13,
+                11,
+                15,
+                12,
+                5,
+                8,
+                9,
+                93
+              ]
+            ],
+            "per_class_recall": [
+              0.42777777777777776,
+              0.4777777777777778,
+              0.5166666666666667,
+              0.39444444444444443,
+              0.4625,
+              0.4777777777777778,
+              0.49444444444444446,
+              0.4666666666666667,
+              0.5166666666666667
+            ],
+            "balanced_accuracy": 0.4705246913580247,
+            "accuracy": 0.47023809523809523,
+            "weighted_f1": 0.4714215675991068,
+            "macro_f1": 0.47182307333007106,
+            "kappa": 0.40322812395229657,
+            "samples": 1680,
+            "reward": 0.4705246913580247,
+            "subjects": 20
+          },
+          "tuev": {
+            "class_counts": [
+              119,
+              291,
+              669,
+              86,
+              500,
+              13822
+            ],
+            "predicted_class_counts": [
+              1415,
+              660,
+              126,
+              754,
+              1684,
+              10848
+            ],
+            "confusion_matrix": [
+              [
+                45,
+                38,
+                15,
+                0,
+                4,
+                17
+              ],
+              [
+                17,
+                164,
+                0,
+                61,
+                49,
+                0
+              ],
+              [
+                130,
+                126,
+                111,
+                89,
+                213,
+                0
+              ],
+              [
+                7,
+                2,
+                0,
+                76,
+                0,
+                1
+              ],
+              [
+                4,
+                0,
+                0,
+                24,
+                435,
+                37
+              ],
+              [
+                1212,
+                330,
+                0,
+                504,
+                983,
+                10793
+              ]
+            ],
+            "per_class_recall": [
+              0.37815126050420167,
+              0.563573883161512,
+              0.16591928251121077,
+              0.8837209302325582,
+              0.87,
+              0.7808566054116626
+            ],
+            "balanced_accuracy": 0.6070369936368575,
+            "accuracy": 0.7505649899916058,
+            "weighted_f1": 0.8137799723660881,
+            "macro_f1": 0.3561849045209278,
+            "kappa": 0.32441309326581047,
+            "samples": 15487,
+            "reward": 0.6070369936368575,
+            "subjects": 58
+          },
+          "ad65": {
+            "class_counts": [
+              464,
+              393,
+              486
+            ],
+            "predicted_class_counts": [
+              440,
+              309,
+              594
+            ],
+            "confusion_matrix": [
+              [
+                287,
+                86,
+                91
+              ],
+              [
+                96,
+                185,
+                112
+              ],
+              [
+                57,
+                38,
+                391
+              ]
+            ],
+            "per_class_recall": [
+              0.6185344827586207,
+              0.4707379134860051,
+              0.8045267489711934
+            ],
+            "balanced_accuracy": 0.6312663817386064,
+            "accuracy": 0.6425912137006702,
+            "weighted_f1": 0.6356338206725993,
+            "macro_f1": 0.6286984511173302,
+            "kappa": 0.4579978610488933,
+            "samples": 1343,
+            "subject_metrics": {
+              "class_counts": [
+                7,
+                5,
+                6
+              ],
+              "predicted_class_counts": [
+                5,
+                6,
+                7
+              ],
+              "confusion_matrix": [
+                [
+                  5,
+                  2,
+                  0
+                ],
+                [
+                  0,
+                  4,
+                  1
+                ],
+                [
+                  0,
+                  0,
+                  6
+                ]
+              ],
+              "per_class_recall": [
+                0.7142857142857143,
+                0.8,
+                1.0
+              ],
+              "balanced_accuracy": 0.8380952380952381,
+              "accuracy": 0.8333333333333334,
+              "weighted_f1": 0.8337865837865839,
+              "macro_f1": 0.8278943278943279,
+              "kappa": 0.7511520737327189
+            },
+            "reward": 0.8380952380952381,
+            "subjects": 18
+          },
+          "openbmi": {
+            "class_counts": [
+              2200,
+              2200
+            ],
+            "predicted_class_counts": [
+              2061,
+              2339
+            ],
+            "confusion_matrix": [
+              [
+                1698,
+                502
+              ],
+              [
+                363,
+                1837
+              ]
+            ],
+            "per_class_recall": [
+              0.7718181818181818,
+              0.835
+            ],
+            "balanced_accuracy": 0.803409090909091,
+            "accuracy": 0.803409090909091,
+            "weighted_f1": 0.8032127000298179,
+            "macro_f1": 0.8032127000298179,
+            "kappa": 0.6068181818181818,
+            "samples": 4400,
+            "subject_scores": {
+              "19": 0.8425,
+              "35": 0.9525,
+              "34": 0.6425000000000001,
+              "51": 0.7475,
+              "20": 0.82,
+              "44": 0.94,
+              "24": 0.5974999999999999,
+              "15": 0.9,
+              "31": 0.8825000000000001,
+              "26": 0.7925,
+              "23": 0.72
+            },
+            "reward": 0.803409090909091,
+            "subjects": 11
+          },
+          "longitudinal": {
+            "class_counts": [
+              4260,
+              4158
+            ],
+            "predicted_class_counts": [
+              4573,
+              3845
+            ],
+            "confusion_matrix": [
+              [
+                3657,
+                603
+              ],
+              [
+                916,
+                3242
+              ]
+            ],
+            "per_class_recall": [
+              0.8584507042253521,
+              0.7797017797017797
+            ],
+            "balanced_accuracy": 0.8190762419635659,
+            "accuracy": 0.8195533380850558,
+            "weighted_f1": 0.8192217642599872,
+            "macro_f1": 0.8191137114479841,
+            "kappa": 0.6387281046963751,
+            "samples": 8418,
+            "subject_scores": {
+              "sub-G2021": 0.837643455629449,
+              "sub-G2007": 0.7644167136410334,
+              "sub-G2019": 0.82505149822325,
+              "sub-G2031": 0.788678938415735,
+              "sub-G2015": 0.8429774626319118,
+              "sub-CTR002": 0.9869493251846193,
+              "sub-G2011": 0.765938925240826,
+              "sub-G2035": 0.9564871486872261,
+              "sub-CTR003": 0.5773809523809523
+            },
+            "reward": 0.8161693800038893,
+            "subjects": 9
+          }
+        },
+        "validation_method": "complete portable infer.sh on all five validation splits"
+      }
+    ],
+    "averaged_validation": {
+      "faced": {
+        "class_counts": [
+          180,
+          180,
+          180,
+          180,
+          240,
+          180,
+          180,
+          180,
+          180
+        ],
+        "predicted_class_counts": [
+          158,
+          189,
+          178,
+          213,
+          242,
+          166,
+          182,
+          176,
+          176
+        ],
+        "confusion_matrix": [
+          [
+            77,
+            14,
+            5,
+            22,
+            19,
+            9,
+            14,
+            10,
+            10
+          ],
+          [
+            12,
+            86,
+            9,
+            13,
+            19,
+            11,
+            14,
+            6,
+            10
+          ],
+          [
+            6,
+            7,
+            93,
+            21,
+            17,
+            5,
+            7,
+            10,
+            14
+          ],
+          [
+            14,
+            18,
+            9,
+            71,
+            21,
+            8,
+            16,
+            15,
+            8
+          ],
+          [
+            13,
+            13,
+            17,
+            26,
+            111,
+            17,
+            14,
+            18,
+            11
+          ],
+          [
+            6,
+            11,
+            11,
+            15,
+            11,
+            86,
+            10,
+            14,
+            16
+          ],
+          [
+            8,
+            11,
+            9,
+            13,
+            17,
+            14,
+            89,
+            10,
+            9
+          ],
+          [
+            8,
+            16,
+            14,
+            17,
+            15,
+            11,
+            10,
+            84,
+            5
+          ],
+          [
+            14,
+            13,
+            11,
+            15,
+            12,
+            5,
+            8,
+            9,
+            93
+          ]
+        ],
+        "per_class_recall": [
+          0.42777777777777776,
+          0.4777777777777778,
+          0.5166666666666667,
+          0.39444444444444443,
+          0.4625,
+          0.4777777777777778,
+          0.49444444444444446,
+          0.4666666666666667,
+          0.5166666666666667
+        ],
+        "balanced_accuracy": 0.4705246913580247,
+        "accuracy": 0.47023809523809523,
+        "weighted_f1": 0.4714215675991068,
+        "macro_f1": 0.47182307333007106,
+        "kappa": 0.40322812395229657,
+        "samples": 1680,
+        "reward": 0.4705246913580247,
+        "subjects": 20
+      },
+      "tuev": {
+        "class_counts": [
+          119,
+          291,
+          669,
+          86,
+          500,
+          13822
+        ],
+        "predicted_class_counts": [
+          1415,
+          660,
+          126,
+          754,
+          1684,
+          10848
+        ],
+        "confusion_matrix": [
+          [
+            45,
+            38,
+            15,
+            0,
+            4,
+            17
+          ],
+          [
+            17,
+            164,
+            0,
+            61,
+            49,
+            0
+          ],
+          [
+            130,
+            126,
+            111,
+            89,
+            213,
+            0
+          ],
+          [
+            7,
+            2,
+            0,
+            76,
+            0,
+            1
+          ],
+          [
+            4,
+            0,
+            0,
+            24,
+            435,
+            37
+          ],
+          [
+            1212,
+            330,
+            0,
+            504,
+            983,
+            10793
+          ]
+        ],
+        "per_class_recall": [
+          0.37815126050420167,
+          0.563573883161512,
+          0.16591928251121077,
+          0.8837209302325582,
+          0.87,
+          0.7808566054116626
+        ],
+        "balanced_accuracy": 0.6070369936368575,
+        "accuracy": 0.7505649899916058,
+        "weighted_f1": 0.8137799723660881,
+        "macro_f1": 0.3561849045209278,
+        "kappa": 0.32441309326581047,
+        "samples": 15487,
+        "reward": 0.6070369936368575,
+        "subjects": 58
+      },
+      "ad65": {
+        "class_counts": [
+          464,
+          393,
+          486
+        ],
+        "predicted_class_counts": [
+          440,
+          309,
+          594
+        ],
+        "confusion_matrix": [
+          [
+            287,
+            86,
+            91
+          ],
+          [
+            96,
+            185,
+            112
+          ],
+          [
+            57,
+            38,
+            391
+          ]
+        ],
+        "per_class_recall": [
+          0.6185344827586207,
+          0.4707379134860051,
+          0.8045267489711934
+        ],
+        "balanced_accuracy": 0.6312663817386064,
+        "accuracy": 0.6425912137006702,
+        "weighted_f1": 0.6356338206725993,
+        "macro_f1": 0.6286984511173302,
+        "kappa": 0.4579978610488933,
+        "samples": 1343,
+        "subject_metrics": {
+          "class_counts": [
+            7,
+            5,
+            6
+          ],
+          "predicted_class_counts": [
+            5,
+            6,
+            7
+          ],
+          "confusion_matrix": [
+            [
+              5,
+              2,
+              0
+            ],
+            [
+              0,
+              4,
+              1
+            ],
+            [
+              0,
+              0,
+              6
+            ]
+          ],
+          "per_class_recall": [
+            0.7142857142857143,
+            0.8,
+            1.0
+          ],
+          "balanced_accuracy": 0.8380952380952381,
+          "accuracy": 0.8333333333333334,
+          "weighted_f1": 0.8337865837865839,
+          "macro_f1": 0.8278943278943279,
+          "kappa": 0.7511520737327189
+        },
+        "reward": 0.8380952380952381,
+        "subjects": 18
+      },
+      "openbmi": {
+        "class_counts": [
+          2200,
+          2200
+        ],
+        "predicted_class_counts": [
+          2061,
+          2339
+        ],
+        "confusion_matrix": [
+          [
+            1698,
+            502
+          ],
+          [
+            363,
+            1837
+          ]
+        ],
+        "per_class_recall": [
+          0.7718181818181818,
+          0.835
+        ],
+        "balanced_accuracy": 0.803409090909091,
+        "accuracy": 0.803409090909091,
+        "weighted_f1": 0.8032127000298179,
+        "macro_f1": 0.8032127000298179,
+        "kappa": 0.6068181818181818,
+        "samples": 4400,
+        "subject_scores": {
+          "19": 0.8425,
+          "35": 0.9525,
+          "34": 0.6425000000000001,
+          "51": 0.7475,
+          "20": 0.82,
+          "44": 0.94,
+          "24": 0.5974999999999999,
+          "15": 0.9,
+          "31": 0.8825000000000001,
+          "26": 0.7925,
+          "23": 0.72
+        },
+        "reward": 0.803409090909091,
+        "subjects": 11
+      },
+      "longitudinal": {
+        "class_counts": [
+          4260,
+          4158
+        ],
+        "predicted_class_counts": [
+          4573,
+          3845
+        ],
+        "confusion_matrix": [
+          [
+            3657,
+            603
+          ],
+          [
+            916,
+            3242
+          ]
+        ],
+        "per_class_recall": [
+          0.8584507042253521,
+          0.7797017797017797
+        ],
+        "balanced_accuracy": 0.8190762419635659,
+        "accuracy": 0.8195533380850558,
+        "weighted_f1": 0.8192217642599872,
+        "macro_f1": 0.8191137114479841,
+        "kappa": 0.6387281046963751,
+        "samples": 8418,
+        "subject_scores": {
+          "sub-G2021": 0.837643455629449,
+          "sub-G2007": 0.7644167136410334,
+          "sub-G2019": 0.82505149822325,
+          "sub-G2031": 0.788678938415735,
+          "sub-G2015": 0.8429774626319118,
+          "sub-CTR002": 0.9869493251846193,
+          "sub-G2011": 0.765938925240826,
+          "sub-G2035": 0.9564871486872261,
+          "sub-CTR003": 0.5773809523809523
+        },
+        "reward": 0.8161693800038893,
+        "subjects": 9
+      }
+    },
+    "settings": {
+      "source": "/workspace/research/runs/hybrid_biot_csp_stable1/epoch-001",
+      "head_arithmetic": "same linear head in fixed feature blocks, sum in bfloat16 on GPU for non-AD tracks; AD remains float32",
+      "weights_unchanged": true
+    }
+  },
+  "selected_head_epochs": {
+    "faced": 0,
+    "tuev": 0,
+    "ad65": 0,
+    "openbmi": 0,
+    "longitudinal": 16
+  },
+  "incumbent_heads": "/workspace/research/runs/head_refinement1/epoch-012",
+  "clinical_training_teacher": {
+    "source": "/workspace/research/runs/hybrid_biot_readout1/epoch-009",
+    "weights_sha256": "3216b27a1cfb7c1e927da0d91a61c7d516f71236a8adf89d84bc9cfbb932313f",
+    "manifest_sha256": "49b7880052e6d093633e6e03d52bfd7df9084271ebf8e4f60e4fbe12da398354",
+    "split": "train",
+    "count": 68445,
+    "source_trained_jointly_on_all_five_tracks": true
+  },
+  "no_prediction_ensemble": true
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S016/config.json

@@ -0,0 +1,205 @@
+{
+  "schema": "bci-shared-biot-covariance-bf16head-v1",
+  "architecture": {
+    "channels": 32,
+    "width": 128,
+    "depth": 2,
+    "dropout": 0.5,
+    "wave_filters": 32,
+    "head_width": 64,
+    "head_dropout": 0.3
+  },
+  "initialization": {
+    "initialization": "continue joint training from a complete shared-model checkpoint",
+    "parent": "/workspace/research/runs/hybrid_biot_fusionshrink0100/epoch-001/weights.pt",
+    "parent_initialization": {
+      "initialization": "jointly trained parent plus audited pretrained BIOT in a single coupled backbone",
+      "parent": "/workspace/research/runs/hybrid_wide1/epoch-004/weights.pt",
+      "audited_biot": {
+        "initialization": "pretrained",
+        "repo": "braindecode/biot-pretrained-six-datasets-18chs",
+        "revision": "7e9aabf302870012f73773276803aab97993951c",
+        "sha256": "a218f4054ae29962c6fd9d23d94c446d354c4f53e805a6771c85749ccc20baaa",
+        "license": "BSD-3-Clause",
+        "source_braindecode": "1.3.0",
+        "loaded_core_tensors": 56,
+        "skipped_classifier_tensors": 3
+      },
+      "neural_channel_indices": {
+        "faced": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "tuev": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15
+        ],
+        "ad65": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "openbmi": [
+          0,
+          1,
+          3,
+          5,
+          12,
+          14,
+          23,
+          25,
+          28,
+          30,
+          2,
+          6,
+          11,
+          15,
+          22,
+          26,
+          4,
+          13
+        ],
+        "longitudinal": [
+          0,
+          2,
+          7,
+          11,
+          23,
+          27,
+          41,
+          45,
+          55,
+          57,
+          5,
+          13,
+          21,
+          29,
+          39,
+          47,
+          9,
+          25
+        ]
+      },
+      "rebase": "incumbent waveform, fusion and four heads; joint BIOT and TUEV head from readout epoch 9; zero initialized neural interaction",
+      "jointly_finetuned_neural_parent": "/workspace/research/runs/hybrid_biot_readout1/epoch-009/weights.pt",
+      "tuev_high_dimensional_spectral_projection_disabled": true,
+      "frozen_prior_representation": true,
+      "nonclinical_head_updates": "only the 256 added BIOT columns; original columns and biases fixed",
+      "faced_openbmi_neural_path": "common nonlinear fusion only; direct head columns masked",
+      "retention_teacher": "/workspace/research/runs/hybrid_wide1/epoch-004",
+      "retention_loss": {
+        "split": "train",
+        "temperature": 2.0,
+        "kl_weight": 1.0,
+        "tracks": [
+          "faced",
+          "ad65",
+          "openbmi",
+          "longitudinal"
+        ]
+      }
+    },
+    "joint_covariance_parent": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+    "frozen_prior_representation": true,
+    "head_updates": "one linear head per track; added 128 shared covariance columns trainable; AD head initialized from the joint covariance parent",
+    "new_shared_representation": "one common covariance MLP inside the coupled backbone, trained by all five tasks; fixed spatial input adapters from the same jointly trained source",
+    "head_arithmetic": "one linear head evaluated in fixed feature blocks to preserve original bfloat16 accumulation dimensions",
+    "retention_teacher": {
+      "ad65": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+      "other_tracks": "/workspace/research/runs/hybrid_wide1/epoch-004"
+    },
+    "retention_loss": {
+      "split": "train",
+      "temperature": 2.0,
+      "kl_weight": 1.0,
+      "tracks": [
+        "faced",
+        "ad65",
+        "openbmi",
+        "longitudinal"
+      ]
+    }
+  },
+  "loader_scale": 0.01,
+  "tracks": [
+    "faced",
+    "tuev",
+    "ad65",
+    "openbmi",
+    "longitudinal"
+  ],
+  "head_arithmetic": "same linear head in fixed feature blocks, sum in bfloat16 on GPU for non-AD tracks; AD remains float32",
+  "head_refinement": {
+    "source": "/workspace/research/runs/residual_heads1/epoch-018",
+    "source_weights_sha256": "e0b609137391b47f99438ccadaa22fc0bc10d2c10ead0ddf0a3c25be2c907c85",
+    "shared_backbone_unchanged": true,
+    "selected_head_epochs": {
+      "faced": 5,
+      "tuev": 24,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 0
+    }
+  },
+  "clinical_spectral_refinement": {
+    "source": "/workspace/research/runs/head_dropout1/epoch-016",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "head_estimation": {
+    "method": "class/subject-balanced Gaussian linear discriminant with shrunk within-class covariance",
+    "selected_shrinkage": {
+      "faced": "inherited",
+      "tuev": "inherited",
+      "ad65": "inherited",
+      "openbmi": "inherited",
+      "longitudinal": 0.9
+    },
+    "feature_scaling": "fitted on training data and folded into linear coefficients"
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S016/covariances.py

@@ -0,0 +1,25 @@
+"""Shared neural filter-bank covariance decoder with spatial input adapters."""
+import torch
+from torch import nn
+SPECS={'faced':(32,10,9),'tuev':(16,5,6),'ad65':(19,10,3),'openbmi':(62,4,2),'longitudinal':(58,2,2)}
+TRACKS=tuple(SPECS)
+BANDS=[(1,4),(4,8),(8,12),(12,16),(16,20),(20,24),(24,28),(28,32),(32,40),(40,48)]
+
+@torch.no_grad()
+def extract_covariances(t,x):
+    x=torch.nan_to_num(x.float().flatten(2)).clamp(-1e5,1e5)
+    x=x-x.mean(-1,keepdim=True)
+    if t in ('faced','tuev'):
+        x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+    else:x=x-x.mean(1,keepdim=True)
+    # Per-window normalization, preserving spatial and frequency power ratios.
+    x=x/x.square().mean((1,2),keepdim=True).clamp_min(1e-12).sqrt()
+    frames=x.unfold(-1,400,200);frames=frames-frames.mean(-1,keepdim=True)
+    z=torch.fft.rfft(frames*torch.hann_window(400,device=x.device),dim=-1)/200
+    covs=[]
+    for lo,hi in BANDS:
+        v=z[...,2*lo:2*hi].flatten(2)
+        cov=(v.real@v.real.transpose(-1,-2)+v.imag@v.imag.transpose(-1,-2))/v.shape[-1]
+        covs.append(cov)
+    return torch.stack(covs,1)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S016/data.py

@@ -0,0 +1,33 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+import numpy as np
+import torch
+@lru_cache(maxsize=8)
+def array(path):return np.load(path,mmap_mode='r',allow_pickle=False)
+class Dataset(torch.utils.data.Dataset):
+    def __init__(self,root,limit=None,cache=False):
+        self.root=Path(root)
+        self.rows=json.loads((self.root/'manifest.json').read_text())['samples']
+        if limit:self.rows=self.rows[:limit]
+        self.cached=None
+        if cache and self.rows:
+            from collections import defaultdict
+            groups=defaultdict(list)
+            for i,r in enumerate(self.rows):groups[r['path']].append((i,r['index']))
+            for name,indices in groups.items():
+                path=(self.root/name).resolve()
+                if not path.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+                source=np.load(path,mmap_mode='r',allow_pickle=False)
+                if self.cached is None:self.cached=torch.empty((len(self.rows),*source.shape[1:]),dtype=torch.float32)
+                dst,src=zip(*indices)
+                self.cached[list(dst)]=torch.as_tensor(source[list(src)]/100,dtype=torch.float32)
+    def __len__(self):return len(self.rows)
+    def __getitem__(self,i):
+        r=self.rows[i]
+        if self.cached is not None:return self.cached[i],r.get('label',-1),r['id']
+        p=(self.root/r['path']).resolve()
+        if not p.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+        # Division precedes float32 conversion, matching official FACED/TUEV collate.
+        x=np.asarray(array(str(p))[r['index']])/100
+        return torch.as_tensor(x,dtype=torch.float32),r.get('label',-1),r['id']

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S016/features.py

@@ -0,0 +1,63 @@
+"""One shared residual backbone, five linear input adapters and output heads."""
+import torch
+from torch import nn
+
+SPECS = {'faced': (32, 10, 9), 'tuev': (16, 5, 6), 'ad65': (19, 10, 3),
+         'openbmi': (62, 4, 2), 'longitudinal': (58, 2, 2)}
+TRACKS = tuple(SPECS)
+EDGES = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,18,20,22,25,28,32,36,40,45,50,60,70,80,95]
+COV_BANDS = [(1,4),(4,8),(8,12),(12,16),(16,20),(20,28),(28,40)]
+
+def feature_dim(channels):
+    return channels * (4*(len(EDGES)-1)+4) + len(COV_BANDS)*channels*(channels-1)//2
+
+@torch.no_grad()
+def extract_features(track, x):
+    """Fixed features; no batch statistics or fitted inference transformations."""
+    x = x.float().flatten(2)
+    x = torch.nan_to_num(x, nan=0., posinf=1e5, neginf=-1e5).clamp(-1e5,1e5)
+    x = x - x.mean(-1,keepdim=True)
+    if track in ('ad65','openbmi','longitudinal'):
+        x = x - x.mean(1,keepdim=True)
+    rms = x.square().mean(-1).clamp_min(1e-12).sqrt()
+    norm = x / rms.unsqueeze(-1)
+    moments = torch.stack([rms.log(), norm.abs().amax(-1).clamp_min(1).log(),
+                          norm.pow(4).mean(-1).clamp_min(1).log(),
+                          (norm[...,1:]-norm[...,:-1]).square().mean(-1).clamp_min(1e-10).log()],-1)
+    frames = x.unfold(-1,400,200)
+    frames = frames - frames.mean(-1,keepdim=True)
+    window = torch.hann_window(400,device=x.device)
+    z = torch.fft.rfft(frames*window,dim=-1)/200
+    power = z.abs().square()
+    bands = torch.stack([power[...,2*lo:2*hi].mean(-1) for lo,hi in zip(EDGES[:-1],EDGES[1:])],-1)
+    lp = bands.mean(-2).clamp_min(1e-12).log()
+    variation = bands.clamp_min(1e-12).log().std(-2,correction=0)
+    relative_frequency = lp - lp.mean(-1,keepdim=True)
+    relative_channel = lp - lp.mean(1,keepdim=True)
+    parts = [torch.cat([lp, relative_frequency, relative_channel, variation, moments],-1).flatten(1)]
+    ii,jj = torch.triu_indices(x.shape[1],x.shape[1],offset=1,device=x.device)
+    for lo,hi in COV_BANDS:
+        v = z[...,2*lo:2*hi].flatten(2)
+        cov = v.real @ v.real.transpose(-1,-2) + v.imag @ v.imag.transpose(-1,-2)
+        d = cov.diagonal(dim1=-2,dim2=-1).clamp_min(1e-12).sqrt()
+        cor = cov / (d.unsqueeze(1)*d.unsqueeze(2)).clamp_min(1e-12)
+        parts.append(cor[:,ii,jj].clamp(-1,1))
+    result = torch.cat(parts,-1)
+    return torch.nan_to_num(result).clamp(-40,40)
+
+class Standardize(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.register_buffer('mean',torch.zeros(dim))
+        self.register_buffer('scale',torch.ones(dim))
+    def forward(self,x):
+        return ((x-self.mean)/self.scale).clamp(-8,8)
+
+class Residual(nn.Module):
+    def __init__(self,width,dropout):
+        super().__init__()
+        self.net=nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width*2),nn.GELU(),
+                               nn.Dropout(dropout),nn.Linear(width*2,width),nn.Dropout(dropout))
+    def forward(self,x):
+        return x+self.net(x)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S016/infer.py

@@ -0,0 +1,24 @@
+import argparse,json
+from pathlib import Path
+import torch
+from model import HybridModel,SPECS
+from data import Dataset
+from covariances import extract_covariances
+p=argparse.ArgumentParser();p.add_argument('input',type=Path);p.add_argument('output',type=Path);a=p.parse_args()
+root=Path(__file__).resolve().parent;c=json.loads((root/'config.json').read_text());t=json.loads((a.input/'manifest.json').read_text())['track']
+if t not in SPECS:raise ValueError('unknown track')
+torch.set_num_threads(4);device='cuda' if torch.cuda.is_available() else 'cpu'
+m=HybridModel(**c['architecture']).to(device);m.load_state_dict(torch.load(root/'weights.pt',map_location=device,weights_only=True));m.eval()
+a.output.mkdir(parents=True,exist_ok=True)
+with torch.inference_mode(),(a.output/'predictions.jsonl').open('w') as f:
+    for x,_,ids in torch.utils.data.DataLoader(Dataset(a.input),batch_size=64,num_workers=0):
+        # FFT features stay float32; convolutions can use bfloat16 on CUDA.
+        x=x.to(device)
+        from features import extract_features
+        torch.backends.cuda.matmul.allow_tf32=False
+        features=extract_features(t,x)
+        covariances=extract_covariances(t,x)
+        torch.backends.cuda.matmul.allow_tf32=True
+        with torch.autocast(device,dtype=torch.bfloat16,enabled=device=='cuda'):pred=m(t,x,features,covariances=covariances)
+        pp=pred.float().softmax(-1).cpu().numpy()
+        for sid,pr in zip(ids,pp):f.write(json.dumps({'id':sid,'probabilities':pr.tolist()})+'\n')

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S016/infer.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec python "$(dirname -- "$0")/infer.py" "$1" "$2"

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S016/model.py

@@ -0,0 +1,111 @@
+"""One fused waveform/spectral backbone used identically by all five tasks."""
+import torch
+from torch import nn
+from braindecode.models import BIOT
+from features import SPECS,TRACKS,feature_dim,extract_features,Standardize,Residual
+from covariances import BANDS,extract_covariances
+
+class InputAdapter(nn.Module):
+    def __init__(self,c,width,channels,spectral_enabled=True):
+        super().__init__()
+        self.signal=nn.Conv1d(c,channels,1,bias=False)
+        self.neural=nn.Conv1d(c,18,1,bias=False)
+        self.normalizer=Standardize(feature_dim(c))
+        self.spectral=nn.Linear(feature_dim(c),width)
+        self.dropout=nn.Dropout(.1)
+        self.register_buffer("spectral_enabled",torch.tensor(float(spectral_enabled)))
+        self.spatial_weight=nn.Parameter(torch.randn(len(BANDS),24,c)/c**.5)
+    def spatial_features(self,covariances):
+        with torch.autocast(covariances.device.type,enabled=False):
+            w=self.spatial_weight.float()/self.spatial_weight.float().norm(dim=-1,keepdim=True).clamp_min(1e-6)
+            power=torch.einsum('bfc,nbcd,bfd->nbf',w,covariances.float(),w).clamp_min(1e-8).log()
+            return torch.cat([power,power-power.mean(1,keepdim=True)],1).flatten(1)
+    def forward(self,x,features,covariance_features):
+        return self.signal(x).unsqueeze(1),self.spectral_enabled*self.spectral(self.dropout(self.normalizer(features))),self.neural(x),covariance_features
+
+class SharedBackbone(nn.Module):
+    def __init__(self,channels,width,depth,dropout,wave_filters):
+        super().__init__()
+        self.waveform=nn.Sequential(
+            nn.Conv2d(1,wave_filters,(1,64),padding=(0,32),bias=False),nn.GroupNorm(1,wave_filters),
+            nn.Conv2d(wave_filters,2*wave_filters,(channels,1),groups=wave_filters,bias=False),nn.GroupNorm(1,2*wave_filters),nn.ELU(),
+            nn.AvgPool2d((1,4)),nn.Dropout(.35),
+            nn.Conv2d(2*wave_filters,2*wave_filters,(1,16),padding=(0,8),groups=2*wave_filters,bias=False),nn.Conv2d(2*wave_filters,2*wave_filters,1,bias=False),
+            nn.GroupNorm(1,2*wave_filters),nn.ELU(),nn.AvgPool2d((1,8)),nn.Dropout(.35))
+        self.wave_summary=nn.Sequential(nn.AdaptiveAvgPool2d((1,8)),nn.Flatten(),nn.Linear(2*wave_filters*8,width))
+        self.fusion=nn.Sequential(nn.LayerNorm(width),nn.GELU(),nn.Dropout(dropout),
+                                 *[Residual(width,dropout) for _ in range(depth)],nn.LayerNorm(width))
+        # Both representations interact before the shared residual stack.
+        self.wave_gain=nn.Parameter(torch.tensor(.1))
+        self.biot=BIOT(n_chans=18,n_outputs=2,n_times=400,sfreq=200)
+        self.biot.final_layer=nn.Identity()
+        self.biot_projection=nn.Sequential(nn.LayerNorm(256),nn.Linear(256,width),nn.Dropout(.2))
+        nn.init.normal_(self.biot_projection[1].weight,std=.001);nn.init.zeros_(self.biot_projection[1].bias)
+        self.covariance_encoder=nn.Sequential(nn.LayerNorm(len(BANDS)*24*2),nn.Linear(len(BANDS)*24*2,width),nn.GELU(),nn.Dropout(.4),
+                                             *[Residual(width,.4) for _ in range(2)],nn.LayerNorm(width))
+        self.covariance_projection=nn.Linear(width,width)
+        nn.init.zeros_(self.covariance_projection.weight);nn.init.zeros_(self.covariance_projection.bias)
+    def forward(self,signal,spectral,neural_signal,covariance_features):
+        wave=self.waveform(signal)
+        neural=self.biot(neural_signal.float())
+        neural=self.biot_projection[0](neural)
+        projected=self.biot_projection[2](self.biot_projection[1](neural))
+        with torch.autocast(signal.device.type,enabled=False):
+            covariance_embedding=self.covariance_encoder(covariance_features.float())
+        original=spectral+self.wave_gain*self.wave_summary(wave)+.01*projected
+        coupled=.001*self.covariance_projection(covariance_embedding).to(original.dtype)
+        fused=self.fusion(original+coupled)
+        return torch.cat([wave.flatten(1),fused,neural,covariance_embedding],-1)
+
+class ResidualHead(nn.Module):
+    """A small nonlinear classifier correction around an inherited linear readout."""
+    def __init__(self,features,classes,width=64,dropout=.3,full_precision=False):
+        super().__init__();self.full_precision=full_precision
+        self.base=nn.Linear(features,classes)
+        self.delta=nn.Sequential(nn.LayerNorm(features),nn.Linear(features,width),nn.GELU(),nn.Dropout(dropout),nn.Linear(width,classes))
+        nn.init.zeros_(self.delta[-1].weight);nn.init.zeros_(self.delta[-1].bias)
+    def forward(self,x):
+        if self.full_precision:
+            with torch.autocast(x.device.type,enabled=False):return self.base(x.float())+self.delta(x.float())
+        prior=nn.functional.linear(x[:,:-128].contiguous(),self.base.weight[:,:-128].contiguous(),self.base.bias)
+        added=nn.functional.linear(x[:,-128:].contiguous(),self.base.weight[:,-128:].contiguous())
+        value=prior+added
+        return value+self.delta(x).to(value.dtype)
+
+class HybridModel(nn.Module):
+    def __init__(self,channels=32,width=128,depth=2,dropout=.5,wave_filters=32,head_width=64,head_dropout=.3):
+        super().__init__()
+        self.adapters=nn.ModuleDict({t:InputAdapter(c,width,channels,spectral_enabled=t not in ("faced","tuev","openbmi")) for t,(c,s,k) in SPECS.items()})
+        self.backbone=SharedBackbone(channels,width,depth,dropout,wave_filters)
+        self.heads=nn.ModuleDict({t:ResidualHead(2*wave_filters*(((s*200+1)//4+1)//8)+width+256+width,k,head_width,head_dropout,full_precision=t=='ad65') for t,(c,s,k) in SPECS.items()})
+    def forward(self,t,x,features=None,covariances=None,covariance_features=None):
+        if features is None:features=extract_features(t,x)
+        if covariance_features is None:
+            if covariances is None:covariances=extract_covariances(t,x)
+            covariance_features=self.adapters[t].spatial_features(covariances)
+        signal=x.flatten(2);signal=signal-signal.mean(-1,keepdim=True)
+        if t in ('faced','tuev'):signal=signal/signal.std(-1,keepdim=True,correction=0).clamp_min(1e-6)
+        else:signal=signal-signal.mean(1,keepdim=True)
+        signal=signal.clamp(-20,20)
+        adapted=self.adapters[t](signal,features,covariance_features)
+        representation=self.backbone(*adapted)
+        if t in ('faced','openbmi'):
+            representation=torch.cat([representation[:,:-384],torch.zeros_like(representation[:,-384:-128]),representation[:,-128:]],-1)
+        return self.heads[t](representation)
+
+def widen_state_dict(state,multiplier=2):
+    """Duplicate temporal features and divide downstream sums to preserve outputs."""
+    result={}
+    for key,value in state.items():
+        if key.startswith('backbone.waveform.'):
+            layer=int(key.split('.')[2])
+            if layer in (0,2,7):value=value.repeat(multiplier,1,1,1)
+            elif layer in (1,3,9):value=value.repeat(multiplier)
+            elif layer==8:value=value.repeat(multiplier,multiplier,1,1)/multiplier
+        elif key=='backbone.wave_summary.2.weight':value=value.repeat(1,multiplier)/multiplier
+        elif key.startswith('heads.') and key.endswith('.weight'):
+            raw=value[:,:-128]/multiplier
+            value=torch.cat([raw]*multiplier+[value[:,-128:]],1)
+        result[key]=value
+    return result
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/alpha_features.py

@@ -0,0 +1,45 @@
+"""Fixed alpha prominence features from each individual two-second window."""
+import torch
+
+REGION_NAMES=('occipital','parietal','central','frontal','left_posterior','right_posterior')
+REGIONS=(('PO7','PO5','PO3','POZ','PO4','PO6','PO8','O1','OZ','O2'),
+         ('P7','P5','P3','P1','PZ','P2','P4','P6','P8'),
+         ('FC5','FC3','FC1','FCZ','FC2','FC4','FC6','C5','C3','C1','CZ','C2','C4','C6'),
+         ('FP1','FPZ','FP2','AF3','AF4','F7','F5','F3','F1','FZ','F2','F4','F6','F8'),
+         ('P7','P5','P3','P1','PO7','PO5','PO3','O1'),
+         ('P2','P4','P6','P8','PO4','PO6','PO8','O2'))
+ALPHA_DIM=58*7+6*22
+
+def region_matrix(channels):
+    result=torch.zeros(len(REGIONS),len(channels))
+    for i,names in enumerate(REGIONS):
+        for name in names:result[i,channels.index(name)]=1/len(names)
+    return result.tolist()
+
+@torch.no_grad()
+def extract_alpha_features(signal,regions):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();x=x-x.mean(-1,keepdim=True)
+        spectrum=torch.fft.rfft(x*torch.hann_window(400,device=x.device),dim=-1)/200
+        power=spectrum.abs().square().clamp_min(1e-12)
+        lp=power.log()
+        # Geometric regional means resist domination by one high-amplitude channel.
+        regional=torch.einsum('rc,ncf->nrf',regions.float(),lp)
+        lp=torch.cat([lp,regional],1)
+        low=lp[...,8:13].mean(-1,keepdim=True)
+        high=lp[...,36:49].mean(-1,keepdim=True)
+        freq=torch.arange(7.,14.5,.5,device=x.device)
+        alpha=lp[...,14:29]
+        baseline=low+(high-low)*((freq-5)/16)
+        prominence=alpha-baseline
+        normalized=alpha.softmax(-1)
+        center=(normalized*freq).sum(-1)
+        entropy=-(normalized*normalized.clamp_min(1e-12).log()).sum(-1)
+        alpha_mean=torch.logsumexp(alpha,-1)-torch.log(torch.tensor(15.,device=x.device))
+        def log_band(lo,hi):
+            return torch.logsumexp(lp[...,lo:hi],-1)-torch.log(torch.tensor(float(hi-lo),device=x.device))
+        summaries=torch.stack([alpha_mean-log_band(2,81),alpha_mean-log_band(8,14),
+                               alpha_mean-log_band(30,61),prominence.max(-1).values,
+                               prominence.mean(-1),center,entropy],-1)
+        return torch.cat([summaries[:,:58].flatten(1),summaries[:,58:].flatten(1),
+                          prominence[:,58:].flatten(1)],1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/config.json

@@ -0,0 +1,611 @@
+{
+  "schema": "bci-shared-biot-covariance-bf16head-v1",
+  "architecture": {
+    "channels": 32,
+    "width": 128,
+    "depth": 2,
+    "dropout": 0.5,
+    "wave_filters": 32,
+    "head_width": 64,
+    "head_dropout": 0.3,
+    "clinical_asymmetry": true,
+    "alpha_regions": [
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.125
+      ]
+    ],
+    "clinical_envelope": true
+  },
+  "initialization": {
+    "initialization": "continue joint training from a complete shared-model checkpoint",
+    "parent": "/workspace/research/runs/hybrid_biot_fusionshrink0100/epoch-001/weights.pt",
+    "parent_initialization": {
+      "initialization": "jointly trained parent plus audited pretrained BIOT in a single coupled backbone",
+      "parent": "/workspace/research/runs/hybrid_wide1/epoch-004/weights.pt",
+      "audited_biot": {
+        "initialization": "pretrained",
+        "repo": "braindecode/biot-pretrained-six-datasets-18chs",
+        "revision": "7e9aabf302870012f73773276803aab97993951c",
+        "sha256": "a218f4054ae29962c6fd9d23d94c446d354c4f53e805a6771c85749ccc20baaa",
+        "license": "BSD-3-Clause",
+        "source_braindecode": "1.3.0",
+        "loaded_core_tensors": 56,
+        "skipped_classifier_tensors": 3
+      },
+      "neural_channel_indices": {
+        "faced": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "tuev": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15
+        ],
+        "ad65": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "openbmi": [
+          0,
+          1,
+          3,
+          5,
+          12,
+          14,
+          23,
+          25,
+          28,
+          30,
+          2,
+          6,
+          11,
+          15,
+          22,
+          26,
+          4,
+          13
+        ],
+        "longitudinal": [
+          0,
+          2,
+          7,
+          11,
+          23,
+          27,
+          41,
+          45,
+          55,
+          57,
+          5,
+          13,
+          21,
+          29,
+          39,
+          47,
+          9,
+          25
+        ]
+      },
+      "rebase": "incumbent waveform, fusion and four heads; joint BIOT and TUEV head from readout epoch 9; zero initialized neural interaction",
+      "jointly_finetuned_neural_parent": "/workspace/research/runs/hybrid_biot_readout1/epoch-009/weights.pt",
+      "tuev_high_dimensional_spectral_projection_disabled": true,
+      "frozen_prior_representation": true,
+      "nonclinical_head_updates": "only the 256 added BIOT columns; original columns and biases fixed",
+      "faced_openbmi_neural_path": "common nonlinear fusion only; direct head columns masked",
+      "retention_teacher": "/workspace/research/runs/hybrid_wide1/epoch-004",
+      "retention_loss": {
+        "split": "train",
+        "temperature": 2.0,
+        "kl_weight": 1.0,
+        "tracks": [
+          "faced",
+          "ad65",
+          "openbmi",
+          "longitudinal"
+        ]
+      }
+    },
+    "joint_covariance_parent": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+    "frozen_prior_representation": true,
+    "head_updates": "one linear head per track; added 128 shared covariance columns trainable; AD head initialized from the joint covariance parent",
+    "new_shared_representation": "one common covariance MLP inside the coupled backbone, trained by all five tasks; fixed spatial input adapters from the same jointly trained source",
+    "head_arithmetic": "one linear head evaluated in fixed feature blocks to preserve original bfloat16 accumulation dimensions",
+    "retention_teacher": {
+      "ad65": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+      "other_tracks": "/workspace/research/runs/hybrid_wide1/epoch-004"
+    },
+    "retention_loss": {
+      "split": "train",
+      "temperature": 2.0,
+      "kl_weight": 1.0,
+      "tracks": [
+        "faced",
+        "ad65",
+        "openbmi",
+        "longitudinal"
+      ]
+    }
+  },
+  "loader_scale": 0.01,
+  "tracks": [
+    "faced",
+    "tuev",
+    "ad65",
+    "openbmi",
+    "longitudinal"
+  ],
+  "head_arithmetic": "same linear head in fixed feature blocks, sum in bfloat16 on GPU for non-AD tracks; AD remains float32",
+  "head_refinement": {
+    "source": "/workspace/research/runs/residual_heads1/epoch-018",
+    "source_weights_sha256": "e0b609137391b47f99438ccadaa22fc0bc10d2c10ead0ddf0a3c25be2c907c85",
+    "shared_backbone_unchanged": true,
+    "selected_head_epochs": {
+      "faced": 5,
+      "tuev": 24,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 0
+    }
+  },
+  "clinical_spectral_refinement": {
+    "source": "/workspace/research/runs/head_dropout1/epoch-016",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "head_estimation": {
+    "method": "class/subject-balanced Gaussian linear discriminant; covariance augmented by class-conditional subject/session mean variation before shrinkage",
+    "selected_shrinkage": {
+      "faced": "inherited",
+      "tuev": "inherited",
+      "ad65": "inherited",
+      "openbmi": "inherited",
+      "longitudinal": {
+        "shrinkage": 0.9,
+        "domain_strength": 1.0
+      }
+    },
+    "feature_scaling": "fitted on training data and folded into linear coefficients"
+  },
+  "clinical_asymmetry_refinement": {
+    "source": "/workspace/research/runs/domain_lda_heads1/epoch-001",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "alpha_rhythm_adapter": {
+    "training_normalization_only": true,
+    "regions": [
+      "occipital",
+      "parietal",
+      "central",
+      "frontal",
+      "left_posterior",
+      "right_posterior"
+    ],
+    "features": "per-window alpha prominence relative to adjacent frequencies",
+    "shared_backbone_unchanged": true
+  },
+  "clinical_envelope_refinement": {
+    "source": "/workspace/research/runs/clinical_asymmetry1/epoch-001",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "independent_adapter_merge": {
+    "alpha_source": "/workspace/research/runs/alpha_calibrated1/epoch-003",
+    "clinical_source": "/workspace/research/runs/clinical_envelope1/epoch-002",
+    "all_shared_and_head_tensors_equal": true
+  },
+  "frequency_montage_refinement": {
+    "six_frequency_bands": true,
+    "shared_encoder_unchanged": true,
+    "selected_track_epochs": {
+      "faced": 0,
+      "tuev": 2,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 2
+    }
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/covariances.py

@@ -0,0 +1,25 @@
+"""Shared neural filter-bank covariance decoder with spatial input adapters."""
+import torch
+from torch import nn
+SPECS={'faced':(32,10,9),'tuev':(16,5,6),'ad65':(19,10,3),'openbmi':(62,4,2),'longitudinal':(58,2,2)}
+TRACKS=tuple(SPECS)
+BANDS=[(1,4),(4,8),(8,12),(12,16),(16,20),(20,24),(24,28),(28,32),(32,40),(40,48)]
+
+@torch.no_grad()
+def extract_covariances(t,x):
+    x=torch.nan_to_num(x.float().flatten(2)).clamp(-1e5,1e5)
+    x=x-x.mean(-1,keepdim=True)
+    if t in ('faced','tuev'):
+        x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+    else:x=x-x.mean(1,keepdim=True)
+    # Per-window normalization, preserving spatial and frequency power ratios.
+    x=x/x.square().mean((1,2),keepdim=True).clamp_min(1e-12).sqrt()
+    frames=x.unfold(-1,400,200);frames=frames-frames.mean(-1,keepdim=True)
+    z=torch.fft.rfft(frames*torch.hann_window(400,device=x.device),dim=-1)/200
+    covs=[]
+    for lo,hi in BANDS:
+        v=z[...,2*lo:2*hi].flatten(2)
+        cov=(v.real@v.real.transpose(-1,-2)+v.imag@v.imag.transpose(-1,-2))/v.shape[-1]
+        covs.append(cov)
+    return torch.stack(covs,1)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/data.py

@@ -0,0 +1,33 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+import numpy as np
+import torch
+@lru_cache(maxsize=8)
+def array(path):return np.load(path,mmap_mode='r',allow_pickle=False)
+class Dataset(torch.utils.data.Dataset):
+    def __init__(self,root,limit=None,cache=False):
+        self.root=Path(root)
+        self.rows=json.loads((self.root/'manifest.json').read_text())['samples']
+        if limit:self.rows=self.rows[:limit]
+        self.cached=None
+        if cache and self.rows:
+            from collections import defaultdict
+            groups=defaultdict(list)
+            for i,r in enumerate(self.rows):groups[r['path']].append((i,r['index']))
+            for name,indices in groups.items():
+                path=(self.root/name).resolve()
+                if not path.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+                source=np.load(path,mmap_mode='r',allow_pickle=False)
+                if self.cached is None:self.cached=torch.empty((len(self.rows),*source.shape[1:]),dtype=torch.float32)
+                dst,src=zip(*indices)
+                self.cached[list(dst)]=torch.as_tensor(source[list(src)]/100,dtype=torch.float32)
+    def __len__(self):return len(self.rows)
+    def __getitem__(self,i):
+        r=self.rows[i]
+        if self.cached is not None:return self.cached[i],r.get('label',-1),r['id']
+        p=(self.root/r['path']).resolve()
+        if not p.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+        # Division precedes float32 conversion, matching official FACED/TUEV collate.
+        x=np.asarray(array(str(p))[r['index']])/100
+        return torch.as_tensor(x,dtype=torch.float32),r.get('label',-1),r['id']

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/envelope_features.py

@@ -0,0 +1,44 @@
+"""Per-window burst-envelope regularity and bilateral synchrony, without fitting."""
+import torch
+import torch.nn.functional as F
+
+BANDS=((1,4),(4,8),(8,13),(13,30),(30,45))
+ENVELOPE_DIM=16*5*12+8*5*2
+
+@torch.no_grad()
+def extract_envelope_features(signal):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();x=x-x.mean(-1,keepdim=True)
+        spectrum=torch.fft.fft(x,dim=-1)
+        frequency=torch.fft.fftfreq(x.shape[-1],1/200,device=x.device)
+        envelopes=[]
+        for lo,hi in BANDS:
+            mask=((frequency>=lo)&(frequency<hi)).to(x.dtype)*2
+            analytic=torch.fft.ifft(spectrum*mask,dim=-1)
+            energy=analytic.abs().square()
+            envelope=F.avg_pool1d(energy.flatten(0,1).unsqueeze(1),20,10).squeeze(1)
+            envelopes.append(envelope.reshape(len(x),16,-1))
+        e=torch.stack(envelopes,2)
+        mean=e.mean(-1,keepdim=True).clamp_min(1e-12)
+        relative=e/mean
+        centered=relative-relative.mean(-1,keepdim=True)
+        std=centered.square().mean(-1,keepdim=True).sqrt().clamp_min(1e-6)
+        normalized=centered/std
+        acf=torch.stack([(normalized[...,:-lag]*normalized[...,lag:]).mean(-1)
+                         for lag in range(4,41)],-1).clamp(-1,1)
+        acf_peak,acf_index=acf.max(-1)
+        probability=(relative/relative.sum(-1,keepdim=True).clamp_min(1e-12)).clamp_min(1e-12)
+        entropy=-(probability*probability.log()).sum(-1)
+        summaries=[std.squeeze(-1).clamp_min(1e-6).log(),relative.amax(-1).clamp_min(1).log(),entropy,
+                   (relative>2).float().mean(-1),(relative>4).float().mean(-1),
+                   ((relative[...,1:]>2)&(relative[...,:-1]<=2)).float().mean(-1),
+                   acf_peak,(acf_index.float()+4)/40,
+                   acf[...,0],acf[...,6],acf[...,16],acf[...,36]]
+        left=torch.tensor([0,1,2,3,8,9,10,11],device=x.device);right=left+4
+        synchrony=(normalized[:,left]*normalized[:,right]).mean(-1).clamp(-1,1)
+        imbalance=(std[:,left].squeeze(-1).log()-std[:,right].squeeze(-1).log()).abs()
+        return torch.cat([torch.stack(summaries,-1).flatten(1),synchrony.flatten(1),imbalance.flatten(1)],1)
+
+def mirrored_features(features):
+    channels=torch.tensor([4,5,6,7,0,1,2,3,12,13,14,15,8,9,10,11],device=features.device)
+    return torch.cat([features[:,:16*5*12].reshape(-1,16,5,12)[:,channels].flatten(1),features[:,16*5*12:]],1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/features.py

@@ -0,0 +1,63 @@
+"""One shared residual backbone, five linear input adapters and output heads."""
+import torch
+from torch import nn
+
+SPECS = {'faced': (32, 10, 9), 'tuev': (16, 5, 6), 'ad65': (19, 10, 3),
+         'openbmi': (62, 4, 2), 'longitudinal': (58, 2, 2)}
+TRACKS = tuple(SPECS)
+EDGES = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,18,20,22,25,28,32,36,40,45,50,60,70,80,95]
+COV_BANDS = [(1,4),(4,8),(8,12),(12,16),(16,20),(20,28),(28,40)]
+
+def feature_dim(channels):
+    return channels * (4*(len(EDGES)-1)+4) + len(COV_BANDS)*channels*(channels-1)//2
+
+@torch.no_grad()
+def extract_features(track, x):
+    """Fixed features; no batch statistics or fitted inference transformations."""
+    x = x.float().flatten(2)
+    x = torch.nan_to_num(x, nan=0., posinf=1e5, neginf=-1e5).clamp(-1e5,1e5)
+    x = x - x.mean(-1,keepdim=True)
+    if track in ('ad65','openbmi','longitudinal'):
+        x = x - x.mean(1,keepdim=True)
+    rms = x.square().mean(-1).clamp_min(1e-12).sqrt()
+    norm = x / rms.unsqueeze(-1)
+    moments = torch.stack([rms.log(), norm.abs().amax(-1).clamp_min(1).log(),
+                          norm.pow(4).mean(-1).clamp_min(1).log(),
+                          (norm[...,1:]-norm[...,:-1]).square().mean(-1).clamp_min(1e-10).log()],-1)
+    frames = x.unfold(-1,400,200)
+    frames = frames - frames.mean(-1,keepdim=True)
+    window = torch.hann_window(400,device=x.device)
+    z = torch.fft.rfft(frames*window,dim=-1)/200
+    power = z.abs().square()
+    bands = torch.stack([power[...,2*lo:2*hi].mean(-1) for lo,hi in zip(EDGES[:-1],EDGES[1:])],-1)
+    lp = bands.mean(-2).clamp_min(1e-12).log()
+    variation = bands.clamp_min(1e-12).log().std(-2,correction=0)
+    relative_frequency = lp - lp.mean(-1,keepdim=True)
+    relative_channel = lp - lp.mean(1,keepdim=True)
+    parts = [torch.cat([lp, relative_frequency, relative_channel, variation, moments],-1).flatten(1)]
+    ii,jj = torch.triu_indices(x.shape[1],x.shape[1],offset=1,device=x.device)
+    for lo,hi in COV_BANDS:
+        v = z[...,2*lo:2*hi].flatten(2)
+        cov = v.real @ v.real.transpose(-1,-2) + v.imag @ v.imag.transpose(-1,-2)
+        d = cov.diagonal(dim1=-2,dim2=-1).clamp_min(1e-12).sqrt()
+        cor = cov / (d.unsqueeze(1)*d.unsqueeze(2)).clamp_min(1e-12)
+        parts.append(cor[:,ii,jj].clamp(-1,1))
+    result = torch.cat(parts,-1)
+    return torch.nan_to_num(result).clamp(-40,40)
+
+class Standardize(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.register_buffer('mean',torch.zeros(dim))
+        self.register_buffer('scale',torch.ones(dim))
+    def forward(self,x):
+        return ((x-self.mean)/self.scale).clamp(-8,8)
+
+class Residual(nn.Module):
+    def __init__(self,width,dropout):
+        super().__init__()
+        self.net=nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width*2),nn.GELU(),
+                               nn.Dropout(dropout),nn.Linear(width*2,width),nn.Dropout(dropout))
+    def forward(self,x):
+        return x+self.net(x)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/frequency_features.py

@@ -0,0 +1,11 @@
+"""Fixed per-window frequency decomposition for a linear montage adapter."""
+import torch
+
+FREQUENCY_BANDS=((1,4),(4,8),(8,13),(13,20),(20,30),(30,45))
+
+def frequency_components(signal):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();spectrum=torch.fft.rfft(x,dim=-1)
+        frequency=torch.fft.rfftfreq(x.shape[-1],d=1/200,device=x.device)
+        masks=torch.stack([((frequency>=lo)&(frequency<hi)).float() for lo,hi in FREQUENCY_BANDS])
+        return torch.fft.irfft(spectrum[:,None]*masks[None,:,None],n=x.shape[-1],dim=-1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/infer.py

@@ -0,0 +1,24 @@
+import argparse,json
+from pathlib import Path
+import torch
+from model import HybridModel,SPECS
+from data import Dataset
+from covariances import extract_covariances
+p=argparse.ArgumentParser();p.add_argument('input',type=Path);p.add_argument('output',type=Path);a=p.parse_args()
+root=Path(__file__).resolve().parent;c=json.loads((root/'config.json').read_text());t=json.loads((a.input/'manifest.json').read_text())['track']
+if t not in SPECS:raise ValueError('unknown track')
+torch.set_num_threads(4);device='cuda' if torch.cuda.is_available() else 'cpu'
+m=HybridModel(**c['architecture']).to(device);m.load_state_dict(torch.load(root/'weights.pt',map_location=device,weights_only=True));m.eval()
+a.output.mkdir(parents=True,exist_ok=True)
+with torch.inference_mode(),(a.output/'predictions.jsonl').open('w') as f:
+    for x,_,ids in torch.utils.data.DataLoader(Dataset(a.input),batch_size=64,num_workers=0):
+        # FFT features stay float32; convolutions can use bfloat16 on CUDA.
+        x=x.to(device)
+        from features import extract_features
+        torch.backends.cuda.matmul.allow_tf32=False
+        features=extract_features(t,x)
+        covariances=extract_covariances(t,x)
+        torch.backends.cuda.matmul.allow_tf32=True
+        with torch.autocast(device,dtype=torch.bfloat16,enabled=device=='cuda'):pred=m(t,x,features,covariances=covariances)
+        pp=pred.float().softmax(-1).cpu().numpy()
+        for sid,pr in zip(ids,pp):f.write(json.dumps({'id':sid,'probabilities':pr.tolist()})+'\n')

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/infer.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec python "$(dirname -- "$0")/infer.py" "$1" "$2"

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S021/model.py

@@ -0,0 +1,161 @@
+"""One fused waveform/spectral backbone used identically by all five tasks."""
+import torch
+from torch import nn
+from braindecode.models import BIOT
+from features import SPECS,TRACKS,feature_dim,extract_features,Standardize,Residual,EDGES,COV_BANDS
+from covariances import BANDS,extract_covariances
+from alpha_features import extract_alpha_features,ALPHA_DIM
+from envelope_features import extract_envelope_features,ENVELOPE_DIM
+from frequency_features import frequency_components,FREQUENCY_BANDS
+
+def clinical_asymmetry_features(features):
+    """Bipolar homologous-channel amplitude and coherence, invariant to mirroring."""
+    bands=len(EDGES)-1;per_channel=4*bands+4
+    block=features[:,:16*per_channel].reshape(-1,16,per_channel)
+    left=torch.tensor([0,1,2,3,8,9,10,11],device=features.device);right=left+4
+    pair_power=(block[:,left,:bands]-block[:,right,:bands]).abs().flatten(1)
+    pair_rms=(block[:,left,4*bands]-block[:,right,4*bands]).abs()
+    hemisphere=(block[:,left,:bands].mean(1)-block[:,right,:bands].mean(1)).abs()
+    index=left*(32-left-1)//2+(right-left-1)
+    correlations=features[:,16*per_channel:].reshape(-1,len(COV_BANDS),120)[:,:,index].flatten(1)
+    return torch.cat([pair_power,pair_rms,hemisphere,correlations],1)
+
+class InputAdapter(nn.Module):
+    def __init__(self,c,width,channels,spectral_enabled=True,asymmetry=False,alpha_regions=None,envelope=False):
+        super().__init__()
+        self.signal=nn.Conv1d(c,channels,1,bias=False)
+        self.frequency_weight=nn.Parameter(torch.zeros(len(FREQUENCY_BANDS),channels,c))
+        self.neural=nn.Conv1d(c,18,1,bias=False)
+        self.normalizer=Standardize(feature_dim(c))
+        self.spectral=nn.Linear(feature_dim(c),width)
+        self.dropout=nn.Dropout(.1)
+        self.register_buffer("spectral_enabled",torch.tensor(float(spectral_enabled)))
+        self.spatial_weight=nn.Parameter(torch.randn(len(BANDS),24,c)/c**.5)
+        self.asymmetry_projection=nn.Linear(316,width,bias=False) if asymmetry else None
+        if asymmetry:
+            nn.init.zeros_(self.asymmetry_projection.weight)
+            self.asymmetry_normalizer=Standardize(316)
+            self.asymmetry_dropout=nn.Dropout(.1)
+        self.alpha_projection=None
+        if alpha_regions is not None:
+            self.register_buffer('alpha_regions',torch.tensor(alpha_regions,dtype=torch.float32))
+            self.alpha_normalizer=Standardize(ALPHA_DIM)
+            self.alpha_projection=nn.Linear(ALPHA_DIM,width,bias=False)
+            nn.init.zeros_(self.alpha_projection.weight)
+            self.alpha_dropout=nn.Dropout(.3)
+        self.envelope_projection=None
+        if envelope:
+            self.envelope_normalizer=Standardize(ENVELOPE_DIM)
+            self.envelope_projection=nn.Linear(ENVELOPE_DIM,width,bias=False)
+            nn.init.zeros_(self.envelope_projection.weight)
+            self.envelope_dropout=nn.Dropout(.3)
+    def spectral_features(self,features,signal=None,alpha_features=None,envelope_features=None):
+        value=self.spectral_enabled*self.spectral(self.dropout(self.normalizer(features)))
+        if self.asymmetry_projection is not None:
+            extra=self.asymmetry_dropout(self.asymmetry_normalizer(clinical_asymmetry_features(features)))
+            value=value+self.asymmetry_projection(extra)
+        if self.alpha_projection is not None:
+            if alpha_features is None:alpha_features=extract_alpha_features(signal,self.alpha_regions)
+            value=value+self.alpha_projection(self.alpha_dropout(self.alpha_normalizer(alpha_features)))
+        if self.envelope_projection is not None:
+            if envelope_features is None:envelope_features=extract_envelope_features(signal)
+            value=value+self.envelope_projection(self.envelope_dropout(self.envelope_normalizer(envelope_features)))
+        return value
+    def spatial_features(self,covariances):
+        with torch.autocast(covariances.device.type,enabled=False):
+            w=self.spatial_weight.float()/self.spatial_weight.float().norm(dim=-1,keepdim=True).clamp_min(1e-6)
+            power=torch.einsum('bfc,nbcd,bfd->nbf',w,covariances.float(),w).clamp_min(1e-8).log()
+            return torch.cat([power,power-power.mean(1,keepdim=True)],1).flatten(1)
+    def wave_signal(self,x,components=None):
+        if components is None:components=frequency_components(x)
+        correction=torch.einsum('blc,nbct->nlt',self.frequency_weight,components.to(self.frequency_weight.dtype))
+        return (self.signal(x)+correction.to(x.dtype)).unsqueeze(1)
+    def forward(self,x,features,covariance_features):
+        return self.wave_signal(x),self.spectral_features(features,signal=x),self.neural(x),covariance_features
+
+class SharedBackbone(nn.Module):
+    def __init__(self,channels,width,depth,dropout,wave_filters):
+        super().__init__()
+        self.waveform=nn.Sequential(
+            nn.Conv2d(1,wave_filters,(1,64),padding=(0,32),bias=False),nn.GroupNorm(1,wave_filters),
+            nn.Conv2d(wave_filters,2*wave_filters,(channels,1),groups=wave_filters,bias=False),nn.GroupNorm(1,2*wave_filters),nn.ELU(),
+            nn.AvgPool2d((1,4)),nn.Dropout(.35),
+            nn.Conv2d(2*wave_filters,2*wave_filters,(1,16),padding=(0,8),groups=2*wave_filters,bias=False),nn.Conv2d(2*wave_filters,2*wave_filters,1,bias=False),
+            nn.GroupNorm(1,2*wave_filters),nn.ELU(),nn.AvgPool2d((1,8)),nn.Dropout(.35))
+        self.wave_summary=nn.Sequential(nn.AdaptiveAvgPool2d((1,8)),nn.Flatten(),nn.Linear(2*wave_filters*8,width))
+        self.fusion=nn.Sequential(nn.LayerNorm(width),nn.GELU(),nn.Dropout(dropout),
+                                 *[Residual(width,dropout) for _ in range(depth)],nn.LayerNorm(width))
+        # Both representations interact before the shared residual stack.
+        self.wave_gain=nn.Parameter(torch.tensor(.1))
+        self.biot=BIOT(n_chans=18,n_outputs=2,n_times=400,sfreq=200)
+        self.biot.final_layer=nn.Identity()
+        self.biot_projection=nn.Sequential(nn.LayerNorm(256),nn.Linear(256,width),nn.Dropout(.2))
+        nn.init.normal_(self.biot_projection[1].weight,std=.001);nn.init.zeros_(self.biot_projection[1].bias)
+        self.covariance_encoder=nn.Sequential(nn.LayerNorm(len(BANDS)*24*2),nn.Linear(len(BANDS)*24*2,width),nn.GELU(),nn.Dropout(.4),
+                                             *[Residual(width,.4) for _ in range(2)],nn.LayerNorm(width))
+        self.covariance_projection=nn.Linear(width,width)
+        nn.init.zeros_(self.covariance_projection.weight);nn.init.zeros_(self.covariance_projection.bias)
+    def forward(self,signal,spectral,neural_signal,covariance_features):
+        wave=self.waveform(signal)
+        neural=self.biot(neural_signal.float())
+        neural=self.biot_projection[0](neural)
+        projected=self.biot_projection[2](self.biot_projection[1](neural))
+        with torch.autocast(signal.device.type,enabled=False):
+            covariance_embedding=self.covariance_encoder(covariance_features.float())
+        original=spectral+self.wave_gain*self.wave_summary(wave)+.01*projected
+        coupled=.001*self.covariance_projection(covariance_embedding).to(original.dtype)
+        fused=self.fusion(original+coupled)
+        return torch.cat([wave.flatten(1),fused,neural,covariance_embedding],-1)
+
+class ResidualHead(nn.Module):
+    """A small nonlinear classifier correction around an inherited linear readout."""
+    def __init__(self,features,classes,width=64,dropout=.3,full_precision=False):
+        super().__init__();self.full_precision=full_precision
+        self.base=nn.Linear(features,classes)
+        self.delta=nn.Sequential(nn.LayerNorm(features),nn.Linear(features,width),nn.GELU(),nn.Dropout(dropout),nn.Linear(width,classes))
+        nn.init.zeros_(self.delta[-1].weight);nn.init.zeros_(self.delta[-1].bias)
+    def forward(self,x):
+        if self.full_precision:
+            with torch.autocast(x.device.type,enabled=False):return self.base(x.float())+self.delta(x.float())
+        prior=nn.functional.linear(x[:,:-128].contiguous(),self.base.weight[:,:-128].contiguous(),self.base.bias)
+        added=nn.functional.linear(x[:,-128:].contiguous(),self.base.weight[:,-128:].contiguous())
+        value=prior+added
+        return value+self.delta(x).to(value.dtype)
+
+class HybridModel(nn.Module):
+    def __init__(self,channels=32,width=128,depth=2,dropout=.5,wave_filters=32,head_width=64,head_dropout=.3,clinical_asymmetry=True,alpha_regions=None,clinical_envelope=False):
+        super().__init__()
+        self.adapters=nn.ModuleDict({t:InputAdapter(c,width,channels,spectral_enabled=t not in ("faced","tuev","openbmi"),asymmetry=clinical_asymmetry and t=="tuev",alpha_regions=alpha_regions if t=="longitudinal" else None,envelope=clinical_envelope and t=="tuev") for t,(c,s,k) in SPECS.items()})
+        self.backbone=SharedBackbone(channels,width,depth,dropout,wave_filters)
+        self.heads=nn.ModuleDict({t:ResidualHead(2*wave_filters*(((s*200+1)//4+1)//8)+width+256+width,k,head_width,head_dropout,full_precision=t=='ad65') for t,(c,s,k) in SPECS.items()})
+    def forward(self,t,x,features=None,covariances=None,covariance_features=None):
+        if features is None:features=extract_features(t,x)
+        if covariance_features is None:
+            if covariances is None:covariances=extract_covariances(t,x)
+            covariance_features=self.adapters[t].spatial_features(covariances)
+        signal=x.flatten(2);signal=signal-signal.mean(-1,keepdim=True)
+        if t in ('faced','tuev'):signal=signal/signal.std(-1,keepdim=True,correction=0).clamp_min(1e-6)
+        else:signal=signal-signal.mean(1,keepdim=True)
+        signal=signal.clamp(-20,20)
+        adapted=self.adapters[t](signal,features,covariance_features)
+        representation=self.backbone(*adapted)
+        if t in ('faced','openbmi'):
+            representation=torch.cat([representation[:,:-384],torch.zeros_like(representation[:,-384:-128]),representation[:,-128:]],-1)
+        return self.heads[t](representation)
+
+def widen_state_dict(state,multiplier=2):
+    """Duplicate temporal features and divide downstream sums to preserve outputs."""
+    result={}
+    for key,value in state.items():
+        if key.startswith('backbone.waveform.'):
+            layer=int(key.split('.')[2])
+            if layer in (0,2,7):value=value.repeat(multiplier,1,1,1)
+            elif layer in (1,3,9):value=value.repeat(multiplier)
+            elif layer==8:value=value.repeat(multiplier,multiplier,1,1)/multiplier
+        elif key=='backbone.wave_summary.2.weight':value=value.repeat(1,multiplier)/multiplier
+        elif key.startswith('heads.') and key.endswith('.weight'):
+            raw=value[:,:-128]/multiplier
+            value=torch.cat([raw]*multiplier+[value[:,-128:]],1)
+        result[key]=value
+    return result
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/alpha_features.py

@@ -0,0 +1,45 @@
+"""Fixed alpha prominence features from each individual two-second window."""
+import torch
+
+REGION_NAMES=('occipital','parietal','central','frontal','left_posterior','right_posterior')
+REGIONS=(('PO7','PO5','PO3','POZ','PO4','PO6','PO8','O1','OZ','O2'),
+         ('P7','P5','P3','P1','PZ','P2','P4','P6','P8'),
+         ('FC5','FC3','FC1','FCZ','FC2','FC4','FC6','C5','C3','C1','CZ','C2','C4','C6'),
+         ('FP1','FPZ','FP2','AF3','AF4','F7','F5','F3','F1','FZ','F2','F4','F6','F8'),
+         ('P7','P5','P3','P1','PO7','PO5','PO3','O1'),
+         ('P2','P4','P6','P8','PO4','PO6','PO8','O2'))
+ALPHA_DIM=58*7+6*22
+
+def region_matrix(channels):
+    result=torch.zeros(len(REGIONS),len(channels))
+    for i,names in enumerate(REGIONS):
+        for name in names:result[i,channels.index(name)]=1/len(names)
+    return result.tolist()
+
+@torch.no_grad()
+def extract_alpha_features(signal,regions):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();x=x-x.mean(-1,keepdim=True)
+        spectrum=torch.fft.rfft(x*torch.hann_window(400,device=x.device),dim=-1)/200
+        power=spectrum.abs().square().clamp_min(1e-12)
+        lp=power.log()
+        # Geometric regional means resist domination by one high-amplitude channel.
+        regional=torch.einsum('rc,ncf->nrf',regions.float(),lp)
+        lp=torch.cat([lp,regional],1)
+        low=lp[...,8:13].mean(-1,keepdim=True)
+        high=lp[...,36:49].mean(-1,keepdim=True)
+        freq=torch.arange(7.,14.5,.5,device=x.device)
+        alpha=lp[...,14:29]
+        baseline=low+(high-low)*((freq-5)/16)
+        prominence=alpha-baseline
+        normalized=alpha.softmax(-1)
+        center=(normalized*freq).sum(-1)
+        entropy=-(normalized*normalized.clamp_min(1e-12).log()).sum(-1)
+        alpha_mean=torch.logsumexp(alpha,-1)-torch.log(torch.tensor(15.,device=x.device))
+        def log_band(lo,hi):
+            return torch.logsumexp(lp[...,lo:hi],-1)-torch.log(torch.tensor(float(hi-lo),device=x.device))
+        summaries=torch.stack([alpha_mean-log_band(2,81),alpha_mean-log_band(8,14),
+                               alpha_mean-log_band(30,61),prominence.max(-1).values,
+                               prominence.mean(-1),center,entropy],-1)
+        return torch.cat([summaries[:,:58].flatten(1),summaries[:,58:].flatten(1),
+                          prominence[:,58:].flatten(1)],1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/config.json

@@ -0,0 +1,637 @@
+{
+  "schema": "bci-shared-biot-covariance-bf16head-v1",
+  "architecture": {
+    "channels": 32,
+    "width": 128,
+    "depth": 2,
+    "dropout": 0.5,
+    "wave_filters": 32,
+    "head_width": 64,
+    "head_dropout": 0.3,
+    "clinical_asymmetry": true,
+    "alpha_regions": [
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.125
+      ]
+    ],
+    "clinical_envelope": true,
+    "temporal_pool": true
+  },
+  "initialization": {
+    "initialization": "continue joint training from a complete shared-model checkpoint",
+    "parent": "/workspace/research/runs/hybrid_biot_fusionshrink0100/epoch-001/weights.pt",
+    "parent_initialization": {
+      "initialization": "jointly trained parent plus audited pretrained BIOT in a single coupled backbone",
+      "parent": "/workspace/research/runs/hybrid_wide1/epoch-004/weights.pt",
+      "audited_biot": {
+        "initialization": "pretrained",
+        "repo": "braindecode/biot-pretrained-six-datasets-18chs",
+        "revision": "7e9aabf302870012f73773276803aab97993951c",
+        "sha256": "a218f4054ae29962c6fd9d23d94c446d354c4f53e805a6771c85749ccc20baaa",
+        "license": "BSD-3-Clause",
+        "source_braindecode": "1.3.0",
+        "loaded_core_tensors": 56,
+        "skipped_classifier_tensors": 3
+      },
+      "neural_channel_indices": {
+        "faced": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "tuev": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15
+        ],
+        "ad65": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "openbmi": [
+          0,
+          1,
+          3,
+          5,
+          12,
+          14,
+          23,
+          25,
+          28,
+          30,
+          2,
+          6,
+          11,
+          15,
+          22,
+          26,
+          4,
+          13
+        ],
+        "longitudinal": [
+          0,
+          2,
+          7,
+          11,
+          23,
+          27,
+          41,
+          45,
+          55,
+          57,
+          5,
+          13,
+          21,
+          29,
+          39,
+          47,
+          9,
+          25
+        ]
+      },
+      "rebase": "incumbent waveform, fusion and four heads; joint BIOT and TUEV head from readout epoch 9; zero initialized neural interaction",
+      "jointly_finetuned_neural_parent": "/workspace/research/runs/hybrid_biot_readout1/epoch-009/weights.pt",
+      "tuev_high_dimensional_spectral_projection_disabled": true,
+      "frozen_prior_representation": true,
+      "nonclinical_head_updates": "only the 256 added BIOT columns; original columns and biases fixed",
+      "faced_openbmi_neural_path": "common nonlinear fusion only; direct head columns masked",
+      "retention_teacher": "/workspace/research/runs/hybrid_wide1/epoch-004",
+      "retention_loss": {
+        "split": "train",
+        "temperature": 2.0,
+        "kl_weight": 1.0,
+        "tracks": [
+          "faced",
+          "ad65",
+          "openbmi",
+          "longitudinal"
+        ]
+      }
+    },
+    "joint_covariance_parent": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+    "frozen_prior_representation": true,
+    "head_updates": "one linear head per track; added 128 shared covariance columns trainable; AD head initialized from the joint covariance parent",
+    "new_shared_representation": "one common covariance MLP inside the coupled backbone, trained by all five tasks; fixed spatial input adapters from the same jointly trained source",
+    "head_arithmetic": "one linear head evaluated in fixed feature blocks to preserve original bfloat16 accumulation dimensions",
+    "retention_teacher": {
+      "ad65": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+      "other_tracks": "/workspace/research/runs/hybrid_wide1/epoch-004"
+    },
+    "retention_loss": {
+      "split": "train",
+      "temperature": 2.0,
+      "kl_weight": 1.0,
+      "tracks": [
+        "faced",
+        "ad65",
+        "openbmi",
+        "longitudinal"
+      ]
+    }
+  },
+  "loader_scale": 0.01,
+  "tracks": [
+    "faced",
+    "tuev",
+    "ad65",
+    "openbmi",
+    "longitudinal"
+  ],
+  "head_arithmetic": "same linear head in fixed feature blocks, sum in bfloat16 on GPU for non-AD tracks; AD remains float32",
+  "head_refinement": {
+    "source": "/workspace/research/runs/residual_heads1/epoch-018",
+    "source_weights_sha256": "e0b609137391b47f99438ccadaa22fc0bc10d2c10ead0ddf0a3c25be2c907c85",
+    "shared_backbone_unchanged": true,
+    "selected_head_epochs": {
+      "faced": 5,
+      "tuev": 24,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 0
+    }
+  },
+  "clinical_spectral_refinement": {
+    "source": "/workspace/research/runs/head_dropout1/epoch-016",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "head_estimation": {
+    "method": "class/subject-balanced Gaussian linear discriminant; covariance augmented by class-conditional subject/session mean variation before shrinkage",
+    "selected_shrinkage": {
+      "faced": "inherited",
+      "tuev": "inherited",
+      "ad65": "inherited",
+      "openbmi": "inherited",
+      "longitudinal": {
+        "shrinkage": 0.9,
+        "domain_strength": 1.0
+      }
+    },
+    "feature_scaling": "fitted on training data and folded into linear coefficients"
+  },
+  "clinical_asymmetry_refinement": {
+    "source": "/workspace/research/runs/domain_lda_heads1/epoch-001",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "alpha_rhythm_adapter": {
+    "training_normalization_only": true,
+    "regions": [
+      "occipital",
+      "parietal",
+      "central",
+      "frontal",
+      "left_posterior",
+      "right_posterior"
+    ],
+    "features": "per-window alpha prominence relative to adjacent frequencies",
+    "shared_backbone_unchanged": true
+  },
+  "clinical_envelope_refinement": {
+    "source": "/workspace/research/runs/clinical_asymmetry1/epoch-001",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "independent_adapter_merge": {
+    "alpha_source": "/workspace/research/runs/alpha_calibrated1/epoch-003",
+    "clinical_source": "/workspace/research/runs/clinical_envelope1/epoch-002",
+    "all_shared_and_head_tensors_equal": true
+  },
+  "frequency_montage_refinement": {
+    "six_frequency_bands": true,
+    "shared_encoder_unchanged": true,
+    "selected_track_epochs": {
+      "faced": 0,
+      "tuev": 1,
+      "ad65": 0,
+      "openbmi": 10,
+      "longitudinal": 2
+    }
+  },
+  "private_track_selection": {
+    "track": "tuev",
+    "donor": "/workspace/research/replicates/frequency_head_control1/epoch-001"
+  },
+  "clinical_sampling_refinement": {
+    "subject_exponent": 0.0,
+    "class_balanced": true,
+    "only_clinical_head_updated": true
+  },
+  "temporal_statistics_readout": {
+    "statistics": [
+      "mean",
+      "standard deviation",
+      "maximum",
+      "minimum"
+    ],
+    "shared_encoder_and_prior_heads_unchanged": true,
+    "selected_pool_epochs": {
+      "faced": 2,
+      "tuev": 0,
+      "ad65": 0,
+      "openbmi": 33,
+      "longitudinal": 3
+    }
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/covariances.py

@@ -0,0 +1,25 @@
+"""Shared neural filter-bank covariance decoder with spatial input adapters."""
+import torch
+from torch import nn
+SPECS={'faced':(32,10,9),'tuev':(16,5,6),'ad65':(19,10,3),'openbmi':(62,4,2),'longitudinal':(58,2,2)}
+TRACKS=tuple(SPECS)
+BANDS=[(1,4),(4,8),(8,12),(12,16),(16,20),(20,24),(24,28),(28,32),(32,40),(40,48)]
+
+@torch.no_grad()
+def extract_covariances(t,x):
+    x=torch.nan_to_num(x.float().flatten(2)).clamp(-1e5,1e5)
+    x=x-x.mean(-1,keepdim=True)
+    if t in ('faced','tuev'):
+        x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+    else:x=x-x.mean(1,keepdim=True)
+    # Per-window normalization, preserving spatial and frequency power ratios.
+    x=x/x.square().mean((1,2),keepdim=True).clamp_min(1e-12).sqrt()
+    frames=x.unfold(-1,400,200);frames=frames-frames.mean(-1,keepdim=True)
+    z=torch.fft.rfft(frames*torch.hann_window(400,device=x.device),dim=-1)/200
+    covs=[]
+    for lo,hi in BANDS:
+        v=z[...,2*lo:2*hi].flatten(2)
+        cov=(v.real@v.real.transpose(-1,-2)+v.imag@v.imag.transpose(-1,-2))/v.shape[-1]
+        covs.append(cov)
+    return torch.stack(covs,1)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/envelope_features.py

@@ -0,0 +1,44 @@
+"""Per-window burst-envelope regularity and bilateral synchrony, without fitting."""
+import torch
+import torch.nn.functional as F
+
+BANDS=((1,4),(4,8),(8,13),(13,30),(30,45))
+ENVELOPE_DIM=16*5*12+8*5*2
+
+@torch.no_grad()
+def extract_envelope_features(signal):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();x=x-x.mean(-1,keepdim=True)
+        spectrum=torch.fft.fft(x,dim=-1)
+        frequency=torch.fft.fftfreq(x.shape[-1],1/200,device=x.device)
+        envelopes=[]
+        for lo,hi in BANDS:
+            mask=((frequency>=lo)&(frequency<hi)).to(x.dtype)*2
+            analytic=torch.fft.ifft(spectrum*mask,dim=-1)
+            energy=analytic.abs().square()
+            envelope=F.avg_pool1d(energy.flatten(0,1).unsqueeze(1),20,10).squeeze(1)
+            envelopes.append(envelope.reshape(len(x),16,-1))
+        e=torch.stack(envelopes,2)
+        mean=e.mean(-1,keepdim=True).clamp_min(1e-12)
+        relative=e/mean
+        centered=relative-relative.mean(-1,keepdim=True)
+        std=centered.square().mean(-1,keepdim=True).sqrt().clamp_min(1e-6)
+        normalized=centered/std
+        acf=torch.stack([(normalized[...,:-lag]*normalized[...,lag:]).mean(-1)
+                         for lag in range(4,41)],-1).clamp(-1,1)
+        acf_peak,acf_index=acf.max(-1)
+        probability=(relative/relative.sum(-1,keepdim=True).clamp_min(1e-12)).clamp_min(1e-12)
+        entropy=-(probability*probability.log()).sum(-1)
+        summaries=[std.squeeze(-1).clamp_min(1e-6).log(),relative.amax(-1).clamp_min(1).log(),entropy,
+                   (relative>2).float().mean(-1),(relative>4).float().mean(-1),
+                   ((relative[...,1:]>2)&(relative[...,:-1]<=2)).float().mean(-1),
+                   acf_peak,(acf_index.float()+4)/40,
+                   acf[...,0],acf[...,6],acf[...,16],acf[...,36]]
+        left=torch.tensor([0,1,2,3,8,9,10,11],device=x.device);right=left+4
+        synchrony=(normalized[:,left]*normalized[:,right]).mean(-1).clamp(-1,1)
+        imbalance=(std[:,left].squeeze(-1).log()-std[:,right].squeeze(-1).log()).abs()
+        return torch.cat([torch.stack(summaries,-1).flatten(1),synchrony.flatten(1),imbalance.flatten(1)],1)
+
+def mirrored_features(features):
+    channels=torch.tensor([4,5,6,7,0,1,2,3,12,13,14,15,8,9,10,11],device=features.device)
+    return torch.cat([features[:,:16*5*12].reshape(-1,16,5,12)[:,channels].flatten(1),features[:,16*5*12:]],1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/frequency_features.py

@@ -0,0 +1,11 @@
+"""Fixed per-window frequency decomposition for a linear montage adapter."""
+import torch
+
+FREQUENCY_BANDS=((1,4),(4,8),(8,13),(13,20),(20,30),(30,45))
+
+def frequency_components(signal):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();spectrum=torch.fft.rfft(x,dim=-1)
+        frequency=torch.fft.rfftfreq(x.shape[-1],d=1/200,device=x.device)
+        masks=torch.stack([((frequency>=lo)&(frequency<hi)).float() for lo,hi in FREQUENCY_BANDS])
+        return torch.fft.irfft(spectrum[:,None]*masks[None,:,None],n=x.shape[-1],dim=-1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/infer.py

@@ -0,0 +1,24 @@
+import argparse,json
+from pathlib import Path
+import torch
+from model import HybridModel,SPECS
+from data import Dataset
+from covariances import extract_covariances
+p=argparse.ArgumentParser();p.add_argument('input',type=Path);p.add_argument('output',type=Path);a=p.parse_args()
+root=Path(__file__).resolve().parent;c=json.loads((root/'config.json').read_text());t=json.loads((a.input/'manifest.json').read_text())['track']
+if t not in SPECS:raise ValueError('unknown track')
+torch.set_num_threads(4);device='cuda' if torch.cuda.is_available() else 'cpu'
+m=HybridModel(**c['architecture']).to(device);m.load_state_dict(torch.load(root/'weights.pt',map_location=device,weights_only=True));m.eval()
+a.output.mkdir(parents=True,exist_ok=True)
+with torch.inference_mode(),(a.output/'predictions.jsonl').open('w') as f:
+    for x,_,ids in torch.utils.data.DataLoader(Dataset(a.input),batch_size=64,num_workers=0):
+        # FFT features stay float32; convolutions can use bfloat16 on CUDA.
+        x=x.to(device)
+        from features import extract_features
+        torch.backends.cuda.matmul.allow_tf32=False
+        features=extract_features(t,x)
+        covariances=extract_covariances(t,x)
+        torch.backends.cuda.matmul.allow_tf32=True
+        with torch.autocast(device,dtype=torch.bfloat16,enabled=device=='cuda'):pred=m(t,x,features,covariances=covariances)
+        pp=pred.float().softmax(-1).cpu().numpy()
+        for sid,pr in zip(ids,pp):f.write(json.dumps({'id':sid,'probabilities':pr.tolist()})+'\n')

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/infer.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec python "$(dirname -- "$0")/infer.py" "$1" "$2"

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S027/model.py

@@ -0,0 +1,179 @@
+"""One fused waveform/spectral backbone used identically by all five tasks."""
+import torch
+from torch import nn
+from braindecode.models import BIOT
+from features import SPECS,TRACKS,feature_dim,extract_features,Standardize,Residual,EDGES,COV_BANDS
+from covariances import BANDS,extract_covariances
+from alpha_features import extract_alpha_features,ALPHA_DIM
+from envelope_features import extract_envelope_features,ENVELOPE_DIM
+from frequency_features import frequency_components,FREQUENCY_BANDS
+
+def clinical_asymmetry_features(features):
+    """Bipolar homologous-channel amplitude and coherence, invariant to mirroring."""
+    bands=len(EDGES)-1;per_channel=4*bands+4
+    block=features[:,:16*per_channel].reshape(-1,16,per_channel)
+    left=torch.tensor([0,1,2,3,8,9,10,11],device=features.device);right=left+4
+    pair_power=(block[:,left,:bands]-block[:,right,:bands]).abs().flatten(1)
+    pair_rms=(block[:,left,4*bands]-block[:,right,4*bands]).abs()
+    hemisphere=(block[:,left,:bands].mean(1)-block[:,right,:bands].mean(1)).abs()
+    index=left*(32-left-1)//2+(right-left-1)
+    correlations=features[:,16*per_channel:].reshape(-1,len(COV_BANDS),120)[:,:,index].flatten(1)
+    return torch.cat([pair_power,pair_rms,hemisphere,correlations],1)
+
+class InputAdapter(nn.Module):
+    def __init__(self,c,width,channels,spectral_enabled=True,asymmetry=False,alpha_regions=None,envelope=False):
+        super().__init__()
+        self.signal=nn.Conv1d(c,channels,1,bias=False)
+        self.frequency_weight=nn.Parameter(torch.zeros(len(FREQUENCY_BANDS),channels,c))
+        self.neural=nn.Conv1d(c,18,1,bias=False)
+        self.normalizer=Standardize(feature_dim(c))
+        self.spectral=nn.Linear(feature_dim(c),width)
+        self.dropout=nn.Dropout(.1)
+        self.register_buffer("spectral_enabled",torch.tensor(float(spectral_enabled)))
+        self.spatial_weight=nn.Parameter(torch.randn(len(BANDS),24,c)/c**.5)
+        self.asymmetry_projection=nn.Linear(316,width,bias=False) if asymmetry else None
+        if asymmetry:
+            nn.init.zeros_(self.asymmetry_projection.weight)
+            self.asymmetry_normalizer=Standardize(316)
+            self.asymmetry_dropout=nn.Dropout(.1)
+        self.alpha_projection=None
+        if alpha_regions is not None:
+            self.register_buffer('alpha_regions',torch.tensor(alpha_regions,dtype=torch.float32))
+            self.alpha_normalizer=Standardize(ALPHA_DIM)
+            self.alpha_projection=nn.Linear(ALPHA_DIM,width,bias=False)
+            nn.init.zeros_(self.alpha_projection.weight)
+            self.alpha_dropout=nn.Dropout(.3)
+        self.envelope_projection=None
+        if envelope:
+            self.envelope_normalizer=Standardize(ENVELOPE_DIM)
+            self.envelope_projection=nn.Linear(ENVELOPE_DIM,width,bias=False)
+            nn.init.zeros_(self.envelope_projection.weight)
+            self.envelope_dropout=nn.Dropout(.3)
+    def spectral_features(self,features,signal=None,alpha_features=None,envelope_features=None):
+        value=self.spectral_enabled*self.spectral(self.dropout(self.normalizer(features)))
+        if self.asymmetry_projection is not None:
+            extra=self.asymmetry_dropout(self.asymmetry_normalizer(clinical_asymmetry_features(features)))
+            value=value+self.asymmetry_projection(extra)
+        if self.alpha_projection is not None:
+            if alpha_features is None:alpha_features=extract_alpha_features(signal,self.alpha_regions)
+            value=value+self.alpha_projection(self.alpha_dropout(self.alpha_normalizer(alpha_features)))
+        if self.envelope_projection is not None:
+            if envelope_features is None:envelope_features=extract_envelope_features(signal)
+            value=value+self.envelope_projection(self.envelope_dropout(self.envelope_normalizer(envelope_features)))
+        return value
+    def spatial_features(self,covariances):
+        with torch.autocast(covariances.device.type,enabled=False):
+            w=self.spatial_weight.float()/self.spatial_weight.float().norm(dim=-1,keepdim=True).clamp_min(1e-6)
+            power=torch.einsum('bfc,nbcd,bfd->nbf',w,covariances.float(),w).clamp_min(1e-8).log()
+            return torch.cat([power,power-power.mean(1,keepdim=True)],1).flatten(1)
+    def wave_signal(self,x,components=None):
+        if components is None:components=frequency_components(x)
+        correction=torch.einsum('blc,nbct->nlt',self.frequency_weight,components.to(self.frequency_weight.dtype))
+        return (self.signal(x)+correction.to(x.dtype)).unsqueeze(1)
+    def forward(self,x,features,covariance_features):
+        return self.wave_signal(x),self.spectral_features(features,signal=x),self.neural(x),covariance_features
+
+class SharedBackbone(nn.Module):
+    def __init__(self,channels,width,depth,dropout,wave_filters):
+        super().__init__()
+        self.waveform=nn.Sequential(
+            nn.Conv2d(1,wave_filters,(1,64),padding=(0,32),bias=False),nn.GroupNorm(1,wave_filters),
+            nn.Conv2d(wave_filters,2*wave_filters,(channels,1),groups=wave_filters,bias=False),nn.GroupNorm(1,2*wave_filters),nn.ELU(),
+            nn.AvgPool2d((1,4)),nn.Dropout(.35),
+            nn.Conv2d(2*wave_filters,2*wave_filters,(1,16),padding=(0,8),groups=2*wave_filters,bias=False),nn.Conv2d(2*wave_filters,2*wave_filters,1,bias=False),
+            nn.GroupNorm(1,2*wave_filters),nn.ELU(),nn.AvgPool2d((1,8)),nn.Dropout(.35))
+        self.wave_summary=nn.Sequential(nn.AdaptiveAvgPool2d((1,8)),nn.Flatten(),nn.Linear(2*wave_filters*8,width))
+        self.fusion=nn.Sequential(nn.LayerNorm(width),nn.GELU(),nn.Dropout(dropout),
+                                 *[Residual(width,dropout) for _ in range(depth)],nn.LayerNorm(width))
+        # Both representations interact before the shared residual stack.
+        self.wave_gain=nn.Parameter(torch.tensor(.1))
+        self.biot=BIOT(n_chans=18,n_outputs=2,n_times=400,sfreq=200)
+        self.biot.final_layer=nn.Identity()
+        self.biot_projection=nn.Sequential(nn.LayerNorm(256),nn.Linear(256,width),nn.Dropout(.2))
+        nn.init.normal_(self.biot_projection[1].weight,std=.001);nn.init.zeros_(self.biot_projection[1].bias)
+        self.covariance_encoder=nn.Sequential(nn.LayerNorm(len(BANDS)*24*2),nn.Linear(len(BANDS)*24*2,width),nn.GELU(),nn.Dropout(.4),
+                                             *[Residual(width,.4) for _ in range(2)],nn.LayerNorm(width))
+        self.covariance_projection=nn.Linear(width,width)
+        nn.init.zeros_(self.covariance_projection.weight);nn.init.zeros_(self.covariance_projection.bias)
+    def forward(self,signal,spectral,neural_signal,covariance_features):
+        wave=self.waveform(signal)
+        neural=self.biot(neural_signal.float())
+        neural=self.biot_projection[0](neural)
+        projected=self.biot_projection[2](self.biot_projection[1](neural))
+        with torch.autocast(signal.device.type,enabled=False):
+            covariance_embedding=self.covariance_encoder(covariance_features.float())
+        original=spectral+self.wave_gain*self.wave_summary(wave)+.01*projected
+        coupled=.001*self.covariance_projection(covariance_embedding).to(original.dtype)
+        fused=self.fusion(original+coupled)
+        return torch.cat([wave.flatten(1),fused,neural,covariance_embedding],-1)
+
+class ResidualHead(nn.Module):
+    """A small nonlinear classifier correction around an inherited linear readout."""
+    def __init__(self,features,classes,width=64,dropout=.3,full_precision=False):
+        super().__init__();self.full_precision=full_precision
+        self.base=nn.Linear(features,classes)
+        self.delta=nn.Sequential(nn.LayerNorm(features),nn.Linear(features,width),nn.GELU(),nn.Dropout(dropout),nn.Linear(width,classes))
+        nn.init.zeros_(self.delta[-1].weight);nn.init.zeros_(self.delta[-1].bias)
+    def forward(self,x):
+        if self.full_precision:
+            with torch.autocast(x.device.type,enabled=False):return self.base(x.float())+self.delta(x.float())
+        prior=nn.functional.linear(x[:,:-128].contiguous(),self.base.weight[:,:-128].contiguous(),self.base.bias)
+        added=nn.functional.linear(x[:,-128:].contiguous(),self.base.weight[:,-128:].contiguous())
+        value=prior+added
+        return value+self.delta(x).to(value.dtype)
+
+class TemporalPoolHead(nn.Module):
+    def __init__(self,prior,channels=64):
+        super().__init__();self.prior=prior;self.channels=channels
+        self.register_buffer('pool_output_scale',torch.ones(()));self.register_buffer('pool_mean',torch.zeros(channels*4));self.register_buffer('pool_scale',torch.ones(channels*4))
+        self.pool_projection=nn.Linear(channels*4,prior.base.out_features)
+        nn.init.zeros_(self.pool_projection.weight);nn.init.zeros_(self.pool_projection.bias)
+    def statistics(self,x):
+        with torch.autocast(x.device.type,enabled=False):
+            wave=x[:,:-512].float().reshape(len(x),self.channels,-1)
+            return torch.cat([wave.mean(-1),wave.std(-1,correction=0),wave.amax(-1),wave.amin(-1)],-1)
+    def forward(self,x):
+        prior=self.prior(x)
+        with torch.autocast(x.device.type,enabled=False):
+            values=((self.statistics(x)-self.pool_mean)/self.pool_scale).clamp(-8,8)
+            added=self.pool_output_scale*self.pool_projection(values)
+        return prior+added.to(prior.dtype)
+
+class HybridModel(nn.Module):
+    def __init__(self,channels=32,width=128,depth=2,dropout=.5,wave_filters=32,head_width=64,head_dropout=.3,clinical_asymmetry=True,alpha_regions=None,clinical_envelope=False,temporal_pool=True):
+        super().__init__()
+        self.adapters=nn.ModuleDict({t:InputAdapter(c,width,channels,spectral_enabled=t not in ("faced","tuev","openbmi"),asymmetry=clinical_asymmetry and t=="tuev",alpha_regions=alpha_regions if t=="longitudinal" else None,envelope=clinical_envelope and t=="tuev") for t,(c,s,k) in SPECS.items()})
+        self.backbone=SharedBackbone(channels,width,depth,dropout,wave_filters)
+        self.heads=nn.ModuleDict({t:ResidualHead(2*wave_filters*(((s*200+1)//4+1)//8)+width+256+width,k,head_width,head_dropout,full_precision=t=='ad65') for t,(c,s,k) in SPECS.items()})
+        if temporal_pool:self.heads=nn.ModuleDict({t:TemporalPoolHead(head,wave_filters*2) for t,head in self.heads.items()})
+    def forward(self,t,x,features=None,covariances=None,covariance_features=None):
+        if features is None:features=extract_features(t,x)
+        if covariance_features is None:
+            if covariances is None:covariances=extract_covariances(t,x)
+            covariance_features=self.adapters[t].spatial_features(covariances)
+        signal=x.flatten(2);signal=signal-signal.mean(-1,keepdim=True)
+        if t in ('faced','tuev'):signal=signal/signal.std(-1,keepdim=True,correction=0).clamp_min(1e-6)
+        else:signal=signal-signal.mean(1,keepdim=True)
+        signal=signal.clamp(-20,20)
+        adapted=self.adapters[t](signal,features,covariance_features)
+        representation=self.backbone(*adapted)
+        if t in ('faced','openbmi'):
+            representation=torch.cat([representation[:,:-384],torch.zeros_like(representation[:,-384:-128]),representation[:,-128:]],-1)
+        return self.heads[t](representation)
+
+def widen_state_dict(state,multiplier=2):
+    """Duplicate temporal features and divide downstream sums to preserve outputs."""
+    result={}
+    for key,value in state.items():
+        if key.startswith('backbone.waveform.'):
+            layer=int(key.split('.')[2])
+            if layer in (0,2,7):value=value.repeat(multiplier,1,1,1)
+            elif layer in (1,3,9):value=value.repeat(multiplier)
+            elif layer==8:value=value.repeat(multiplier,multiplier,1,1)/multiplier
+        elif key=='backbone.wave_summary.2.weight':value=value.repeat(1,multiplier)/multiplier
+        elif key.startswith('heads.') and key.endswith('.weight'):
+            raw=value[:,:-128]/multiplier
+            value=torch.cat([raw]*multiplier+[value[:,-128:]],1)
+        result[key]=value
+    return result
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S032/infer.py

@@ -0,0 +1,24 @@
+import argparse,json
+from pathlib import Path
+import torch
+from model import HybridModel,SPECS
+from data import Dataset
+from covariances import extract_covariances
+p=argparse.ArgumentParser();p.add_argument('input',type=Path);p.add_argument('output',type=Path);a=p.parse_args()
+root=Path(__file__).resolve().parent;c=json.loads((root/'config.json').read_text());t=json.loads((a.input/'manifest.json').read_text())['track']
+if t not in SPECS:raise ValueError('unknown track')
+torch.set_num_threads(4);device='cuda' if torch.cuda.is_available() else 'cpu'
+m=HybridModel(**c['architecture']).to(device);m.load_state_dict(torch.load(root/'weights.pt',map_location=device,weights_only=True));m.eval()
+a.output.mkdir(parents=True,exist_ok=True)
+with torch.inference_mode(),(a.output/'predictions.jsonl').open('w') as f:
+    for x,_,ids in torch.utils.data.DataLoader(Dataset(a.input),batch_size=64,num_workers=0):
+        # FFT features stay float32; convolutions can use bfloat16 on CUDA.
+        x=x.to(device)
+        from features import extract_features
+        torch.backends.cuda.matmul.allow_tf32=False
+        features=extract_features(t,x)
+        covariances=extract_covariances(t,x)
+        torch.backends.cuda.matmul.allow_tf32=True
+        with torch.autocast(device,dtype=torch.bfloat16,enabled=device=='cuda'):pred=m(t,x,features,covariances=covariances)
+        pp=pred.float().softmax(-1).cpu().numpy()
+        for sid,pr in zip(ids,pp):f.write(json.dumps({'id':sid,'probabilities':pr.tolist()})+'\n')

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S033/alpha_features.py

@@ -0,0 +1,45 @@
+"""Fixed alpha prominence features from each individual two-second window."""
+import torch
+
+REGION_NAMES=('occipital','parietal','central','frontal','left_posterior','right_posterior')
+REGIONS=(('PO7','PO5','PO3','POZ','PO4','PO6','PO8','O1','OZ','O2'),
+         ('P7','P5','P3','P1','PZ','P2','P4','P6','P8'),
+         ('FC5','FC3','FC1','FCZ','FC2','FC4','FC6','C5','C3','C1','CZ','C2','C4','C6'),
+         ('FP1','FPZ','FP2','AF3','AF4','F7','F5','F3','F1','FZ','F2','F4','F6','F8'),
+         ('P7','P5','P3','P1','PO7','PO5','PO3','O1'),
+         ('P2','P4','P6','P8','PO4','PO6','PO8','O2'))
+ALPHA_DIM=58*7+6*22
+
+def region_matrix(channels):
+    result=torch.zeros(len(REGIONS),len(channels))
+    for i,names in enumerate(REGIONS):
+        for name in names:result[i,channels.index(name)]=1/len(names)
+    return result.tolist()
+
+@torch.no_grad()
+def extract_alpha_features(signal,regions):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();x=x-x.mean(-1,keepdim=True)
+        spectrum=torch.fft.rfft(x*torch.hann_window(400,device=x.device),dim=-1)/200
+        power=spectrum.abs().square().clamp_min(1e-12)
+        lp=power.log()
+        # Geometric regional means resist domination by one high-amplitude channel.
+        regional=torch.einsum('rc,ncf->nrf',regions.float(),lp)
+        lp=torch.cat([lp,regional],1)
+        low=lp[...,8:13].mean(-1,keepdim=True)
+        high=lp[...,36:49].mean(-1,keepdim=True)
+        freq=torch.arange(7.,14.5,.5,device=x.device)
+        alpha=lp[...,14:29]
+        baseline=low+(high-low)*((freq-5)/16)
+        prominence=alpha-baseline
+        normalized=alpha.softmax(-1)
+        center=(normalized*freq).sum(-1)
+        entropy=-(normalized*normalized.clamp_min(1e-12).log()).sum(-1)
+        alpha_mean=torch.logsumexp(alpha,-1)-torch.log(torch.tensor(15.,device=x.device))
+        def log_band(lo,hi):
+            return torch.logsumexp(lp[...,lo:hi],-1)-torch.log(torch.tensor(float(hi-lo),device=x.device))
+        summaries=torch.stack([alpha_mean-log_band(2,81),alpha_mean-log_band(8,14),
+                               alpha_mean-log_band(30,61),prominence.max(-1).values,
+                               prominence.mean(-1),center,entropy],-1)
+        return torch.cat([summaries[:,:58].flatten(1),summaries[:,58:].flatten(1),
+                          prominence[:,58:].flatten(1)],1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S033/covariances.py

@@ -0,0 +1,25 @@
+"""Shared neural filter-bank covariance decoder with spatial input adapters."""
+import torch
+from torch import nn
+SPECS={'faced':(32,10,9),'tuev':(16,5,6),'ad65':(19,10,3),'openbmi':(62,4,2),'longitudinal':(58,2,2)}
+TRACKS=tuple(SPECS)
+BANDS=[(1,4),(4,8),(8,12),(12,16),(16,20),(20,24),(24,28),(28,32),(32,40),(40,48)]
+
+@torch.no_grad()
+def extract_covariances(t,x):
+    x=torch.nan_to_num(x.float().flatten(2)).clamp(-1e5,1e5)
+    x=x-x.mean(-1,keepdim=True)
+    if t in ('faced','tuev'):
+        x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+    else:x=x-x.mean(1,keepdim=True)
+    # Per-window normalization, preserving spatial and frequency power ratios.
+    x=x/x.square().mean((1,2),keepdim=True).clamp_min(1e-12).sqrt()
+    frames=x.unfold(-1,400,200);frames=frames-frames.mean(-1,keepdim=True)
+    z=torch.fft.rfft(frames*torch.hann_window(400,device=x.device),dim=-1)/200
+    covs=[]
+    for lo,hi in BANDS:
+        v=z[...,2*lo:2*hi].flatten(2)
+        cov=(v.real@v.real.transpose(-1,-2)+v.imag@v.imag.transpose(-1,-2))/v.shape[-1]
+        covs.append(cov)
+    return torch.stack(covs,1)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S033/data.py

@@ -0,0 +1,33 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+import numpy as np
+import torch
+@lru_cache(maxsize=8)
+def array(path):return np.load(path,mmap_mode='r',allow_pickle=False)
+class Dataset(torch.utils.data.Dataset):
+    def __init__(self,root,limit=None,cache=False):
+        self.root=Path(root)
+        self.rows=json.loads((self.root/'manifest.json').read_text())['samples']
+        if limit:self.rows=self.rows[:limit]
+        self.cached=None
+        if cache and self.rows:
+            from collections import defaultdict
+            groups=defaultdict(list)
+            for i,r in enumerate(self.rows):groups[r['path']].append((i,r['index']))
+            for name,indices in groups.items():
+                path=(self.root/name).resolve()
+                if not path.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+                source=np.load(path,mmap_mode='r',allow_pickle=False)
+                if self.cached is None:self.cached=torch.empty((len(self.rows),*source.shape[1:]),dtype=torch.float32)
+                dst,src=zip(*indices)
+                self.cached[list(dst)]=torch.as_tensor(source[list(src)]/100,dtype=torch.float32)
+    def __len__(self):return len(self.rows)
+    def __getitem__(self,i):
+        r=self.rows[i]
+        if self.cached is not None:return self.cached[i],r.get('label',-1),r['id']
+        p=(self.root/r['path']).resolve()
+        if not p.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+        # Division precedes float32 conversion, matching official FACED/TUEV collate.
+        x=np.asarray(array(str(p))[r['index']])/100
+        return torch.as_tensor(x,dtype=torch.float32),r.get('label',-1),r['id']

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S033/features.py

@@ -0,0 +1,63 @@
+"""One shared residual backbone, five linear input adapters and output heads."""
+import torch
+from torch import nn
+
+SPECS = {'faced': (32, 10, 9), 'tuev': (16, 5, 6), 'ad65': (19, 10, 3),
+         'openbmi': (62, 4, 2), 'longitudinal': (58, 2, 2)}
+TRACKS = tuple(SPECS)
+EDGES = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,18,20,22,25,28,32,36,40,45,50,60,70,80,95]
+COV_BANDS = [(1,4),(4,8),(8,12),(12,16),(16,20),(20,28),(28,40)]
+
+def feature_dim(channels):
+    return channels * (4*(len(EDGES)-1)+4) + len(COV_BANDS)*channels*(channels-1)//2
+
+@torch.no_grad()
+def extract_features(track, x):
+    """Fixed features; no batch statistics or fitted inference transformations."""
+    x = x.float().flatten(2)
+    x = torch.nan_to_num(x, nan=0., posinf=1e5, neginf=-1e5).clamp(-1e5,1e5)
+    x = x - x.mean(-1,keepdim=True)
+    if track in ('ad65','openbmi','longitudinal'):
+        x = x - x.mean(1,keepdim=True)
+    rms = x.square().mean(-1).clamp_min(1e-12).sqrt()
+    norm = x / rms.unsqueeze(-1)
+    moments = torch.stack([rms.log(), norm.abs().amax(-1).clamp_min(1).log(),
+                          norm.pow(4).mean(-1).clamp_min(1).log(),
+                          (norm[...,1:]-norm[...,:-1]).square().mean(-1).clamp_min(1e-10).log()],-1)
+    frames = x.unfold(-1,400,200)
+    frames = frames - frames.mean(-1,keepdim=True)
+    window = torch.hann_window(400,device=x.device)
+    z = torch.fft.rfft(frames*window,dim=-1)/200
+    power = z.abs().square()
+    bands = torch.stack([power[...,2*lo:2*hi].mean(-1) for lo,hi in zip(EDGES[:-1],EDGES[1:])],-1)
+    lp = bands.mean(-2).clamp_min(1e-12).log()
+    variation = bands.clamp_min(1e-12).log().std(-2,correction=0)
+    relative_frequency = lp - lp.mean(-1,keepdim=True)
+    relative_channel = lp - lp.mean(1,keepdim=True)
+    parts = [torch.cat([lp, relative_frequency, relative_channel, variation, moments],-1).flatten(1)]
+    ii,jj = torch.triu_indices(x.shape[1],x.shape[1],offset=1,device=x.device)
+    for lo,hi in COV_BANDS:
+        v = z[...,2*lo:2*hi].flatten(2)
+        cov = v.real @ v.real.transpose(-1,-2) + v.imag @ v.imag.transpose(-1,-2)
+        d = cov.diagonal(dim1=-2,dim2=-1).clamp_min(1e-12).sqrt()
+        cor = cov / (d.unsqueeze(1)*d.unsqueeze(2)).clamp_min(1e-12)
+        parts.append(cor[:,ii,jj].clamp(-1,1))
+    result = torch.cat(parts,-1)
+    return torch.nan_to_num(result).clamp(-40,40)
+
+class Standardize(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.register_buffer('mean',torch.zeros(dim))
+        self.register_buffer('scale',torch.ones(dim))
+    def forward(self,x):
+        return ((x-self.mean)/self.scale).clamp(-8,8)
+
+class Residual(nn.Module):
+    def __init__(self,width,dropout):
+        super().__init__()
+        self.net=nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width*2),nn.GELU(),
+                               nn.Dropout(dropout),nn.Linear(width*2,width),nn.Dropout(dropout))
+    def forward(self,x):
+        return x+self.net(x)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S033/infer.py

@@ -0,0 +1,24 @@
+import argparse,json
+from pathlib import Path
+import torch
+from model import HybridModel,SPECS
+from data import Dataset
+from covariances import extract_covariances
+p=argparse.ArgumentParser();p.add_argument('input',type=Path);p.add_argument('output',type=Path);a=p.parse_args()
+root=Path(__file__).resolve().parent;c=json.loads((root/'config.json').read_text());t=json.loads((a.input/'manifest.json').read_text())['track']
+if t not in SPECS:raise ValueError('unknown track')
+torch.set_num_threads(4);device='cuda' if torch.cuda.is_available() else 'cpu'
+m=HybridModel(**c['architecture']).to(device);m.load_state_dict(torch.load(root/'weights.pt',map_location=device,weights_only=True));m.eval()
+a.output.mkdir(parents=True,exist_ok=True)
+with torch.inference_mode(),(a.output/'predictions.jsonl').open('w') as f:
+    for x,_,ids in torch.utils.data.DataLoader(Dataset(a.input),batch_size=64,num_workers=0):
+        # FFT features stay float32; convolutions can use bfloat16 on CUDA.
+        x=x.to(device)
+        from features import extract_features
+        torch.backends.cuda.matmul.allow_tf32=False
+        features=extract_features(t,x)
+        covariances=extract_covariances(t,x)
+        torch.backends.cuda.matmul.allow_tf32=True
+        with torch.autocast(device,dtype=torch.bfloat16,enabled=device=='cuda'):pred=m(t,x,features,covariances=covariances)
+        pp=pred.float().softmax(-1).cpu().numpy()
+        for sid,pr in zip(ids,pp):f.write(json.dumps({'id':sid,'probabilities':pr.tolist()})+'\n')

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S033/infer.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -euo pipefail
+exec python "$(dirname -- "$0")/infer.py" "$1" "$2"

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S033/tangent_features.py

@@ -0,0 +1,25 @@
+"""Window-local log-correlation geometry in the existing spatial-filter basis."""
+import torch
+
+TANGENT_DIM=10*24*25//2
+
+@torch.no_grad()
+def extract_tangent_features(covariances,spatial_weight):
+    old_tf32=torch.backends.cuda.matmul.allow_tf32
+    torch.backends.cuda.matmul.allow_tf32=False
+    try:
+        with torch.autocast(covariances.device.type,enabled=False):
+            w=spatial_weight.float()
+            w=w/w.norm(dim=-1,keepdim=True).clamp_min(1e-6)
+            projected=torch.einsum('bfc,nbcd,bgd->nbfg',w,covariances.float(),w)
+            d=projected.diagonal(dim1=-2,dim2=-1).clamp_min(1e-10).sqrt()
+            correlation=(projected/(d.unsqueeze(-1)*d.unsqueeze(-2))).clamp(-1,1)
+            correlation=(correlation+correlation.transpose(-1,-2))/2
+            correlation=.95*correlation+.05*torch.eye(24,device=correlation.device)
+            values,vectors=torch.linalg.eigh(correlation)
+            logarithm=(vectors*values.clamp_min(1e-6).log().unsqueeze(-2))@vectors.transpose(-1,-2)
+            i,j=torch.triu_indices(24,24,device=correlation.device)
+            scale=torch.where(i==j,1.,2.**.5)
+            return (logarithm[...,i,j]*scale).flatten(1)
+    finally:
+        torch.backends.cuda.matmul.allow_tf32=old_tf32

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S035/alpha_features.py

@@ -0,0 +1,45 @@
+"""Fixed alpha prominence features from each individual two-second window."""
+import torch
+
+REGION_NAMES=('occipital','parietal','central','frontal','left_posterior','right_posterior')
+REGIONS=(('PO7','PO5','PO3','POZ','PO4','PO6','PO8','O1','OZ','O2'),
+         ('P7','P5','P3','P1','PZ','P2','P4','P6','P8'),
+         ('FC5','FC3','FC1','FCZ','FC2','FC4','FC6','C5','C3','C1','CZ','C2','C4','C6'),
+         ('FP1','FPZ','FP2','AF3','AF4','F7','F5','F3','F1','FZ','F2','F4','F6','F8'),
+         ('P7','P5','P3','P1','PO7','PO5','PO3','O1'),
+         ('P2','P4','P6','P8','PO4','PO6','PO8','O2'))
+ALPHA_DIM=58*7+6*22
+
+def region_matrix(channels):
+    result=torch.zeros(len(REGIONS),len(channels))
+    for i,names in enumerate(REGIONS):
+        for name in names:result[i,channels.index(name)]=1/len(names)
+    return result.tolist()
+
+@torch.no_grad()
+def extract_alpha_features(signal,regions):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();x=x-x.mean(-1,keepdim=True)
+        spectrum=torch.fft.rfft(x*torch.hann_window(400,device=x.device),dim=-1)/200
+        power=spectrum.abs().square().clamp_min(1e-12)
+        lp=power.log()
+        # Geometric regional means resist domination by one high-amplitude channel.
+        regional=torch.einsum('rc,ncf->nrf',regions.float(),lp)
+        lp=torch.cat([lp,regional],1)
+        low=lp[...,8:13].mean(-1,keepdim=True)
+        high=lp[...,36:49].mean(-1,keepdim=True)
+        freq=torch.arange(7.,14.5,.5,device=x.device)
+        alpha=lp[...,14:29]
+        baseline=low+(high-low)*((freq-5)/16)
+        prominence=alpha-baseline
+        normalized=alpha.softmax(-1)
+        center=(normalized*freq).sum(-1)
+        entropy=-(normalized*normalized.clamp_min(1e-12).log()).sum(-1)
+        alpha_mean=torch.logsumexp(alpha,-1)-torch.log(torch.tensor(15.,device=x.device))
+        def log_band(lo,hi):
+            return torch.logsumexp(lp[...,lo:hi],-1)-torch.log(torch.tensor(float(hi-lo),device=x.device))
+        summaries=torch.stack([alpha_mean-log_band(2,81),alpha_mean-log_band(8,14),
+                               alpha_mean-log_band(30,61),prominence.max(-1).values,
+                               prominence.mean(-1),center,entropy],-1)
+        return torch.cat([summaries[:,:58].flatten(1),summaries[:,58:].flatten(1),
+                          prominence[:,58:].flatten(1)],1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S035/config.json

@@ -0,0 +1,682 @@
+{
+  "schema": "bci-shared-biot-covariance-bf16head-v1",
+  "architecture": {
+    "channels": 32,
+    "width": 128,
+    "depth": 2,
+    "dropout": 0.5,
+    "wave_filters": 32,
+    "head_width": 64,
+    "head_dropout": 0.3,
+    "clinical_asymmetry": true,
+    "alpha_regions": [
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612,
+        0.10000000149011612
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.1111111119389534,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0714285746216774,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.0,
+        0.0
+      ],
+      [
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.0,
+        0.0,
+        0.125,
+        0.125,
+        0.125,
+        0.0,
+        0.0,
+        0.125
+      ]
+    ],
+    "clinical_envelope": true,
+    "temporal_pool": true,
+    "temporal_evidence": true,
+    "evidence_temperature": 0.25,
+    "random_fourier": true,
+    "fourier_features": 256,
+    "tangent_readout": true
+  },
+  "initialization": {
+    "initialization": "continue joint training from a complete shared-model checkpoint",
+    "parent": "/workspace/research/runs/hybrid_biot_fusionshrink0100/epoch-001/weights.pt",
+    "parent_initialization": {
+      "initialization": "jointly trained parent plus audited pretrained BIOT in a single coupled backbone",
+      "parent": "/workspace/research/runs/hybrid_wide1/epoch-004/weights.pt",
+      "audited_biot": {
+        "initialization": "pretrained",
+        "repo": "braindecode/biot-pretrained-six-datasets-18chs",
+        "revision": "7e9aabf302870012f73773276803aab97993951c",
+        "sha256": "a218f4054ae29962c6fd9d23d94c446d354c4f53e805a6771c85749ccc20baaa",
+        "license": "BSD-3-Clause",
+        "source_braindecode": "1.3.0",
+        "loaded_core_tensors": 56,
+        "skipped_classifier_tensors": 3
+      },
+      "neural_channel_indices": {
+        "faced": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "tuev": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15
+        ],
+        "ad65": [
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17
+        ],
+        "openbmi": [
+          0,
+          1,
+          3,
+          5,
+          12,
+          14,
+          23,
+          25,
+          28,
+          30,
+          2,
+          6,
+          11,
+          15,
+          22,
+          26,
+          4,
+          13
+        ],
+        "longitudinal": [
+          0,
+          2,
+          7,
+          11,
+          23,
+          27,
+          41,
+          45,
+          55,
+          57,
+          5,
+          13,
+          21,
+          29,
+          39,
+          47,
+          9,
+          25
+        ]
+      },
+      "rebase": "incumbent waveform, fusion and four heads; joint BIOT and TUEV head from readout epoch 9; zero initialized neural interaction",
+      "jointly_finetuned_neural_parent": "/workspace/research/runs/hybrid_biot_readout1/epoch-009/weights.pt",
+      "tuev_high_dimensional_spectral_projection_disabled": true,
+      "frozen_prior_representation": true,
+      "nonclinical_head_updates": "only the 256 added BIOT columns; original columns and biases fixed",
+      "faced_openbmi_neural_path": "common nonlinear fusion only; direct head columns masked",
+      "retention_teacher": "/workspace/research/runs/hybrid_wide1/epoch-004",
+      "retention_loss": {
+        "split": "train",
+        "temperature": 2.0,
+        "kl_weight": 1.0,
+        "tracks": [
+          "faced",
+          "ad65",
+          "openbmi",
+          "longitudinal"
+        ]
+      }
+    },
+    "joint_covariance_parent": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+    "frozen_prior_representation": true,
+    "head_updates": "one linear head per track; added 128 shared covariance columns trainable; AD head initialized from the joint covariance parent",
+    "new_shared_representation": "one common covariance MLP inside the coupled backbone, trained by all five tasks; fixed spatial input adapters from the same jointly trained source",
+    "head_arithmetic": "one linear head evaluated in fixed feature blocks to preserve original bfloat16 accumulation dimensions",
+    "retention_teacher": {
+      "ad65": "/workspace/research/runs/filterbank1/epoch-002/weights.pt",
+      "other_tracks": "/workspace/research/runs/hybrid_wide1/epoch-004"
+    },
+    "retention_loss": {
+      "split": "train",
+      "temperature": 2.0,
+      "kl_weight": 1.0,
+      "tracks": [
+        "faced",
+        "ad65",
+        "openbmi",
+        "longitudinal"
+      ]
+    }
+  },
+  "loader_scale": 0.01,
+  "tracks": [
+    "faced",
+    "tuev",
+    "ad65",
+    "openbmi",
+    "longitudinal"
+  ],
+  "head_arithmetic": "same linear head in fixed feature blocks, sum in bfloat16 on GPU for non-AD tracks; AD remains float32",
+  "head_refinement": {
+    "source": "/workspace/research/runs/residual_heads1/epoch-018",
+    "source_weights_sha256": "e0b609137391b47f99438ccadaa22fc0bc10d2c10ead0ddf0a3c25be2c907c85",
+    "shared_backbone_unchanged": true,
+    "selected_head_epochs": {
+      "faced": 5,
+      "tuev": 24,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 0
+    }
+  },
+  "clinical_spectral_refinement": {
+    "source": "/workspace/research/runs/head_dropout1/epoch-016",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "head_estimation": {
+    "method": "class/subject-balanced Gaussian linear discriminant; covariance augmented by class-conditional subject/session mean variation before shrinkage",
+    "selected_shrinkage": {
+      "faced": "inherited",
+      "tuev": "inherited",
+      "ad65": "inherited",
+      "openbmi": "inherited",
+      "longitudinal": {
+        "shrinkage": 0.9,
+        "domain_strength": 1.0
+      }
+    },
+    "feature_scaling": "fitted on training data and folded into linear coefficients"
+  },
+  "clinical_asymmetry_refinement": {
+    "source": "/workspace/research/runs/domain_lda_heads1/epoch-001",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "alpha_rhythm_adapter": {
+    "training_normalization_only": true,
+    "regions": [
+      "occipital",
+      "parietal",
+      "central",
+      "frontal",
+      "left_posterior",
+      "right_posterior"
+    ],
+    "features": "per-window alpha prominence relative to adjacent frequencies",
+    "shared_backbone_unchanged": true
+  },
+  "clinical_envelope_refinement": {
+    "source": "/workspace/research/runs/clinical_asymmetry1/epoch-001",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  },
+  "independent_adapter_merge": {
+    "alpha_source": "/workspace/research/runs/alpha_calibrated1/epoch-003",
+    "clinical_source": "/workspace/research/runs/clinical_envelope1/epoch-002",
+    "all_shared_and_head_tensors_equal": true
+  },
+  "frequency_montage_refinement": {
+    "six_frequency_bands": true,
+    "shared_encoder_unchanged": true,
+    "selected_track_epochs": {
+      "faced": 0,
+      "tuev": 1,
+      "ad65": 0,
+      "openbmi": 10,
+      "longitudinal": 2
+    }
+  },
+  "private_track_selection": {
+    "track": "tuev",
+    "donor": "/workspace/research/replicates/frequency_head_control1/epoch-001"
+  },
+  "clinical_sampling_refinement": {
+    "subject_exponent": 0.0,
+    "class_balanced": true,
+    "only_clinical_head_updated": true
+  },
+  "temporal_statistics_readout": {
+    "statistics": [
+      "mean",
+      "standard deviation",
+      "maximum",
+      "minimum"
+    ],
+    "shared_encoder_and_prior_heads_unchanged": true,
+    "selected_pool_epochs": {
+      "faced": 2,
+      "tuev": 0,
+      "ad65": 0,
+      "openbmi": 33,
+      "longitudinal": 3
+    }
+  },
+  "temporal_evidence_readout": {
+    "pooling": "log mean exp of per-patch class evidence",
+    "temperature": 0.25,
+    "shared_encoder_and_prior_heads_unchanged": true,
+    "selected_evidence_epochs": {
+      "faced": 0,
+      "tuev": 0,
+      "ad65": 0,
+      "openbmi": 6,
+      "longitudinal": 8
+    }
+  },
+  "fourier_basis_readout": {
+    "basis_functions": 256,
+    "bandwidths": [
+      0.5,
+      1.0,
+      2.0
+    ],
+    "shared_encoder_and_prior_heads_unchanged": true,
+    "selected_fourier_epochs": {
+      "faced": 21,
+      "tuev": 0,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 2
+    }
+  },
+  "shared_tangent_readout": {
+    "one_shared_tangent_module": true,
+    "original_and_corrected_shared_features_retained": true,
+    "private_head_scalar_gains": {
+      "faced": 0.0,
+      "tuev": 0.1,
+      "ad65": 0.0,
+      "openbmi": 1.0,
+      "longitudinal": 0.1
+    },
+    "all_common_weights_fixed_during_gain_refinement": true
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S035/covariances.py

@@ -0,0 +1,25 @@
+"""Shared neural filter-bank covariance decoder with spatial input adapters."""
+import torch
+from torch import nn
+SPECS={'faced':(32,10,9),'tuev':(16,5,6),'ad65':(19,10,3),'openbmi':(62,4,2),'longitudinal':(58,2,2)}
+TRACKS=tuple(SPECS)
+BANDS=[(1,4),(4,8),(8,12),(12,16),(16,20),(20,24),(24,28),(28,32),(32,40),(40,48)]
+
+@torch.no_grad()
+def extract_covariances(t,x):
+    x=torch.nan_to_num(x.float().flatten(2)).clamp(-1e5,1e5)
+    x=x-x.mean(-1,keepdim=True)
+    if t in ('faced','tuev'):
+        x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+    else:x=x-x.mean(1,keepdim=True)
+    # Per-window normalization, preserving spatial and frequency power ratios.
+    x=x/x.square().mean((1,2),keepdim=True).clamp_min(1e-12).sqrt()
+    frames=x.unfold(-1,400,200);frames=frames-frames.mean(-1,keepdim=True)
+    z=torch.fft.rfft(frames*torch.hann_window(400,device=x.device),dim=-1)/200
+    covs=[]
+    for lo,hi in BANDS:
+        v=z[...,2*lo:2*hi].flatten(2)
+        cov=(v.real@v.real.transpose(-1,-2)+v.imag@v.imag.transpose(-1,-2))/v.shape[-1]
+        covs.append(cov)
+    return torch.stack(covs,1)
+

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S035/data.py

@@ -0,0 +1,33 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+import numpy as np
+import torch
+@lru_cache(maxsize=8)
+def array(path):return np.load(path,mmap_mode='r',allow_pickle=False)
+class Dataset(torch.utils.data.Dataset):
+    def __init__(self,root,limit=None,cache=False):
+        self.root=Path(root)
+        self.rows=json.loads((self.root/'manifest.json').read_text())['samples']
+        if limit:self.rows=self.rows[:limit]
+        self.cached=None
+        if cache and self.rows:
+            from collections import defaultdict
+            groups=defaultdict(list)
+            for i,r in enumerate(self.rows):groups[r['path']].append((i,r['index']))
+            for name,indices in groups.items():
+                path=(self.root/name).resolve()
+                if not path.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+                source=np.load(path,mmap_mode='r',allow_pickle=False)
+                if self.cached is None:self.cached=torch.empty((len(self.rows),*source.shape[1:]),dtype=torch.float32)
+                dst,src=zip(*indices)
+                self.cached[list(dst)]=torch.as_tensor(source[list(src)]/100,dtype=torch.float32)
+    def __len__(self):return len(self.rows)
+    def __getitem__(self,i):
+        r=self.rows[i]
+        if self.cached is not None:return self.cached[i],r.get('label',-1),r['id']
+        p=(self.root/r['path']).resolve()
+        if not p.is_relative_to(self.root.resolve()):raise ValueError('input outside root')
+        # Division precedes float32 conversion, matching official FACED/TUEV collate.
+        x=np.asarray(array(str(p))[r['index']])/100
+        return torch.as_tensor(x,dtype=torch.float32),r.get('label',-1),r['id']

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S035/envelope_features.py

@@ -0,0 +1,44 @@
+"""Per-window burst-envelope regularity and bilateral synchrony, without fitting."""
+import torch
+import torch.nn.functional as F
+
+BANDS=((1,4),(4,8),(8,13),(13,30),(30,45))
+ENVELOPE_DIM=16*5*12+8*5*2
+
+@torch.no_grad()
+def extract_envelope_features(signal):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=signal.float();x=x-x.mean(-1,keepdim=True)
+        spectrum=torch.fft.fft(x,dim=-1)
+        frequency=torch.fft.fftfreq(x.shape[-1],1/200,device=x.device)
+        envelopes=[]
+        for lo,hi in BANDS:
+            mask=((frequency>=lo)&(frequency<hi)).to(x.dtype)*2
+            analytic=torch.fft.ifft(spectrum*mask,dim=-1)
+            energy=analytic.abs().square()
+            envelope=F.avg_pool1d(energy.flatten(0,1).unsqueeze(1),20,10).squeeze(1)
+            envelopes.append(envelope.reshape(len(x),16,-1))
+        e=torch.stack(envelopes,2)
+        mean=e.mean(-1,keepdim=True).clamp_min(1e-12)
+        relative=e/mean
+        centered=relative-relative.mean(-1,keepdim=True)
+        std=centered.square().mean(-1,keepdim=True).sqrt().clamp_min(1e-6)
+        normalized=centered/std
+        acf=torch.stack([(normalized[...,:-lag]*normalized[...,lag:]).mean(-1)
+                         for lag in range(4,41)],-1).clamp(-1,1)
+        acf_peak,acf_index=acf.max(-1)
+        probability=(relative/relative.sum(-1,keepdim=True).clamp_min(1e-12)).clamp_min(1e-12)
+        entropy=-(probability*probability.log()).sum(-1)
+        summaries=[std.squeeze(-1).clamp_min(1e-6).log(),relative.amax(-1).clamp_min(1).log(),entropy,
+                   (relative>2).float().mean(-1),(relative>4).float().mean(-1),
+                   ((relative[...,1:]>2)&(relative[...,:-1]<=2)).float().mean(-1),
+                   acf_peak,(acf_index.float()+4)/40,
+                   acf[...,0],acf[...,6],acf[...,16],acf[...,36]]
+        left=torch.tensor([0,1,2,3,8,9,10,11],device=x.device);right=left+4
+        synchrony=(normalized[:,left]*normalized[:,right]).mean(-1).clamp(-1,1)
+        imbalance=(std[:,left].squeeze(-1).log()-std[:,right].squeeze(-1).log()).abs()
+        return torch.cat([torch.stack(summaries,-1).flatten(1),synchrony.flatten(1),imbalance.flatten(1)],1)
+
+def mirrored_features(features):
+    channels=torch.tensor([4,5,6,7,0,1,2,3,12,13,14,15,8,9,10,11],device=features.device)
+    return torch.cat([features[:,:16*5*12].reshape(-1,16,5,12)[:,channels].flatten(1),features[:,16*5*12:]],1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S035/features.py

@@ -0,0 +1,63 @@
+"""One shared residual backbone, five linear input adapters and output heads."""
+import torch
+from torch import nn
+
+SPECS = {'faced': (32, 10, 9), 'tuev': (16, 5, 6), 'ad65': (19, 10, 3),
+         'openbmi': (62, 4, 2), 'longitudinal': (58, 2, 2)}
+TRACKS = tuple(SPECS)
+EDGES = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,18,20,22,25,28,32,36,40,45,50,60,70,80,95]
+COV_BANDS = [(1,4),(4,8),(8,12),(12,16),(16,20),(20,28),(28,40)]
+
+def feature_dim(channels):
+    return channels * (4*(len(EDGES)-1)+4) + len(COV_BANDS)*channels*(channels-1)//2
+
+@torch.no_grad()
+def extract_features(track, x):
+    """Fixed features; no batch statistics or fitted inference transformations."""
+    x = x.float().flatten(2)
+    x = torch.nan_to_num(x, nan=0., posinf=1e5, neginf=-1e5).clamp(-1e5,1e5)
+    x = x - x.mean(-1,keepdim=True)
+    if track in ('ad65','openbmi','longitudinal'):
+        x = x - x.mean(1,keepdim=True)
+    rms = x.square().mean(-1).clamp_min(1e-12).sqrt()
+    norm = x / rms.unsqueeze(-1)
+    moments = torch.stack([rms.log(), norm.abs().amax(-1).clamp_min(1).log(),
+                          norm.pow(4).mean(-1).clamp_min(1).log(),
+                          (norm[...,1:]-norm[...,:-1]).square().mean(-1).clamp_min(1e-10).log()],-1)
+    frames = x.unfold(-1,400,200)
+    frames = frames - frames.mean(-1,keepdim=True)
+    window = torch.hann_window(400,device=x.device)
+    z = torch.fft.rfft(frames*window,dim=-1)/200
+    power = z.abs().square()
+    bands = torch.stack([power[...,2*lo:2*hi].mean(-1) for lo,hi in zip(EDGES[:-1],EDGES[1:])],-1)
+    lp = bands.mean(-2).clamp_min(1e-12).log()
+    variation = bands.clamp_min(1e-12).log().std(-2,correction=0)
+    relative_frequency = lp - lp.mean(-1,keepdim=True)
+    relative_channel = lp - lp.mean(1,keepdim=True)
+    parts = [torch.cat([lp, relative_frequency, relative_channel, variation, moments],-1).flatten(1)]
+    ii,jj = torch.triu_indices(x.shape[1],x.shape[1],offset=1,device=x.device)
+    for lo,hi in COV_BANDS:
+        v = z[...,2*lo:2*hi].flatten(2)
+        cov = v.real @ v.real.transpose(-1,-2) + v.imag @ v.imag.transpose(-1,-2)
+        d = cov.diagonal(dim1=-2,dim2=-1).clamp_min(1e-12).sqrt()
+        cor = cov / (d.unsqueeze(1)*d.unsqueeze(2)).clamp_min(1e-12)
+        parts.append(cor[:,ii,jj].clamp(-1,1))
+    result = torch.cat(parts,-1)
+    return torch.nan_to_num(result).clamp(-40,40)
+
+class Standardize(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.register_buffer('mean',torch.zeros(dim))
+        self.register_buffer('scale',torch.ones(dim))
+    def forward(self,x):
+        return ((x-self.mean)/self.scale).clamp(-8,8)
+
+class Residual(nn.Module):
+    def __init__(self,width,dropout):
+        super().__init__()
+        self.net=nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width*2),nn.GELU(),
+                               nn.Dropout(dropout),nn.Linear(width*2,width),nn.Dropout(dropout))
+    def forward(self,x):
+        return x+self.net(x)
+