Add files using upload-large-folder tool

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S003/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/S004/config.json

@@ -0,0 +1,22 @@
+{
+  "schema": "bci-fused-shared-backbone-v1",
+  "architecture": {
+    "channels": 32,
+    "width": 128,
+    "depth": 2,
+    "dropout": 0.5
+  },
+  "initialization": {
+    "initialization": "jointly trained waveform and spectral stems, initialized task heads, coupled shared feature fusion",
+    "waveform_parent": "/workspace/research/runs/eegnet1/epoch-016/weights.pt",
+    "spectral_parent": "/workspace/research/runs/spectral2/epoch-010/weights.pt"
+  },
+  "loader_scale": 0.01,
+  "tracks": [
+    "faced",
+    "tuev",
+    "ad65",
+    "openbmi",
+    "longitudinal"
+  ]
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S004/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/S004/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/S004/infer.py

@@ -0,0 +1,20 @@
+import argparse,json
+from pathlib import Path
+import torch
+from model import HybridModel,SPECS
+from data import Dataset
+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
+        features=extract_features(t,x)
+        with torch.autocast(device,dtype=torch.bfloat16,enabled=device=='cuda'):pred=m(t,x,features)
+        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/S004/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/S004/model.py

@@ -0,0 +1,74 @@
+"""One fused waveform/spectral backbone used identically by all five tasks."""
+import torch
+from torch import nn
+from features import SPECS,TRACKS,feature_dim,extract_features,Standardize,Residual
+
+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.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)))
+    def forward(self,x,features):
+        return self.signal(x).unsqueeze(1),self.spectral_enabled*self.spectral(self.dropout(self.normalizer(features)))
+
+class SharedBackbone(nn.Module):
+    def __init__(self,channels,width,depth,dropout):
+        super().__init__()
+        self.waveform=nn.Sequential(
+            nn.Conv2d(1,16,(1,64),padding=(0,32),bias=False),nn.GroupNorm(1,16),
+            nn.Conv2d(16,32,(channels,1),groups=16,bias=False),nn.GroupNorm(1,32),nn.ELU(),
+            nn.AvgPool2d((1,4)),nn.Dropout(.35),
+            nn.Conv2d(32,32,(1,16),padding=(0,8),groups=32,bias=False),nn.Conv2d(32,32,1,bias=False),
+            nn.GroupNorm(1,32),nn.ELU(),nn.AvgPool2d((1,8)),nn.Dropout(.35))
+        self.wave_summary=nn.Sequential(nn.AdaptiveAvgPool2d((1,8)),nn.Flatten(),nn.Linear(256,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))
+    def forward(self,signal,spectral):
+        wave=self.waveform(signal)
+        fused=self.fusion(spectral+self.wave_gain*self.wave_summary(wave))
+        return torch.cat([wave.flatten(1),fused],-1)
+
+class HybridModel(nn.Module):
+    def __init__(self,channels=32,width=128,depth=2,dropout=.5):
+        super().__init__()
+        self.adapters=nn.ModuleDict({t:InputAdapter(c,width,channels,spectral_enabled=t not in ("faced","openbmi")) for t,(c,s,k) in SPECS.items()})
+        self.backbone=SharedBackbone(channels,width,depth,dropout)
+        self.heads=nn.ModuleDict({t:nn.Linear(32*(((s*200+1)//4+1)//8)+width,k) for t,(c,s,k) in SPECS.items()})
+    def forward(self,t,x,features=None):
+        if features is None:features=extract_features(t,x)
+        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)
+        return self.heads[t](self.backbone(*adapted))
+
+    def initialize_stems(self,waveform_state,spectral_state):
+        self.backbone.waveform.load_state_dict({k.removeprefix('backbone.'):v for k,v in waveform_state.items() if k.startswith('backbone.')})
+        self.backbone.fusion.load_state_dict({k.removeprefix('backbone.'):v for k,v in spectral_state.items() if k.startswith('backbone.')})
+        for t in TRACKS:
+            self.adapters[t].signal.load_state_dict({'weight':waveform_state[f'adapters.{t}.weight']})
+            self.adapters[t].normalizer.load_state_dict({k:spectral_state[f'normalizers.{t}.{k}'] for k in ('mean','scale')})
+            self.adapters[t].spectral.load_state_dict({k:spectral_state[f'adapters.{t}.{k}'] for k in ('weight','bias')})
+        with torch.no_grad():
+            for t in TRACKS:
+                self.heads[t].weight.zero_()
+                # Each head starts from the representation supported by validation.
+                # Shared waveform-to-spectral coupling remains active for every task.
+                if t in ('faced','openbmi'):
+                    self.heads[t].weight[:,:-128].copy_(waveform_state[f'heads.{t}.weight'])
+                    self.heads[t].weight[:,-128:].normal_(0,.001)
+                    self.heads[t].bias.copy_(waveform_state[f'heads.{t}.bias'])
+                elif t in ('ad65','longitudinal'):
+                    self.heads[t].weight[:,-128:].copy_(spectral_state[f'heads.{t}.weight'])
+                    self.heads[t].weight[:,:-128].normal_(0,.001)
+                    self.heads[t].bias.copy_(spectral_state[f'heads.{t}.bias'])
+                else:
+                    self.heads[t].weight[:,:-128].copy_(waveform_state[f'heads.{t}.weight']*.5)
+                    self.heads[t].weight[:,-128:].copy_(spectral_state[f'heads.{t}.weight']*.5)
+                    self.heads[t].bias.copy_((spectral_state[f'heads.{t}.bias']+waveform_state[f'heads.{t}.bias'])*.5)

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

@@ -0,0 +1,843 @@
+{
+  "settings": {
+    "output": "/workspace/research/runs/hybrid_distill1",
+    "epochs": 15,
+    "steps": 500,
+    "batch_size": 64,
+    "seed": 7,
+    "hidden": 32,
+    "dropout": 0.5,
+    "lr": 2e-05,
+    "head_lr": 5e-05,
+    "weight_decay": 0.05,
+    "waveform_parent": "/workspace/research/runs/eegnet1/epoch-016/weights.pt",
+    "spectral_parent": "/workspace/research/runs/spectral2/epoch-010/weights.pt",
+    "init": "/workspace/research/runs/hybrid_mil1/epoch-006/weights.pt",
+    "mixup": 0.0,
+    "ad_pool": 8
+  },
+  "all_tracks_update_shared_backbone": true,
+  "history": [
+    {
+      "epoch": 1,
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            168,
+            187,
+            165,
+            227,
+            237,
+            153,
+            182,
+            183,
+            178
+          ],
+          "confusion_matrix": [
+            [
+              80,
+              14,
+              6,
+              23,
+              19,
+              6,
+              10,
+              11,
+              11
+            ],
+            [
+              13,
+              75,
+              9,
+              20,
+              21,
+              11,
+              16,
+              7,
+              8
+            ],
+            [
+              7,
+              9,
+              86,
+              21,
+              16,
+              6,
+              7,
+              12,
+              16
+            ],
+            [
+              18,
+              21,
+              7,
+              68,
+              19,
+              6,
+              15,
+              18,
+              8
+            ],
+            [
+              14,
+              18,
+              15,
+              27,
+              104,
+              19,
+              16,
+              18,
+              9
+            ],
+            [
+              7,
+              10,
+              10,
+              18,
+              13,
+              80,
+              11,
+              15,
+              16
+            ],
+            [
+              10,
+              10,
+              9,
+              14,
+              17,
+              13,
+              88,
+              10,
+              9
+            ],
+            [
+              6,
+              17,
+              12,
+              22,
+              16,
+              9,
+              9,
+              82,
+              7
+            ],
+            [
+              13,
+              13,
+              11,
+              14,
+              12,
+              3,
+              10,
+              10,
+              94
+            ]
+          ],
+          "per_class_recall": [
+            0.4444444444444444,
+            0.4166666666666667,
+            0.4777777777777778,
+            0.37777777777777777,
+            0.43333333333333335,
+            0.4444444444444444,
+            0.4888888888888889,
+            0.45555555555555555,
+            0.5222222222222223
+          ],
+          "balanced_accuracy": 0.45123456790123456,
+          "accuracy": 0.4505952380952381,
+          "weighted_f1": 0.45280743688486585,
+          "macro_f1": 0.45342776046542965,
+          "kappa": 0.3811747240380241,
+          "samples": 1680,
+          "reward": 0.45123456790123456,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            85,
+            611,
+            72,
+            100,
+            2140,
+            12479
+          ],
+          "confusion_matrix": [
+            [
+              31,
+              19,
+              6,
+              0,
+              0,
+              63
+            ],
+            [
+              0,
+              12,
+              0,
+              0,
+              279,
+              0
+            ],
+            [
+              10,
+              113,
+              0,
+              0,
+              545,
+              1
+            ],
+            [
+              0,
+              26,
+              0,
+              52,
+              0,
+              8
+            ],
+            [
+              0,
+              1,
+              0,
+              0,
+              468,
+              31
+            ],
+            [
+              44,
+              440,
+              66,
+              48,
+              848,
+              12376
+            ]
+          ],
+          "per_class_recall": [
+            0.2605042016806723,
+            0.041237113402061855,
+            0.0,
+            0.6046511627906976,
+            0.936,
+            0.8953841701635075
+          ],
+          "balanced_accuracy": 0.4562961080061565,
+          "accuracy": 0.8354749144443727,
+          "weighted_f1": 0.8573138858544057,
+          "macro_f1": 0.3642198746460232,
+          "kappa": 0.4025401653746039,
+          "samples": 15487,
+          "reward": 0.4562961080061565,
+          "subjects": 58
+        },
+        "ad65": {
+          "class_counts": [
+            464,
+            393,
+            486
+          ],
+          "predicted_class_counts": [
+            516,
+            321,
+            506
+          ],
+          "confusion_matrix": [
+            [
+              320,
+              109,
+              35
+            ],
+            [
+              131,
+              187,
+              75
+            ],
+            [
+              65,
+              25,
+              396
+            ]
+          ],
+          "per_class_recall": [
+            0.6896551724137931,
+            0.4758269720101781,
+            0.8148148148148148
+          ],
+          "balanced_accuracy": 0.6600989864129287,
+          "accuracy": 0.6723752792256142,
+          "weighted_f1": 0.6678285033899227,
+          "macro_f1": 0.658419281691171,
+          "kappa": 0.5043266149732082,
+          "samples": 1343,
+          "subject_metrics": {
+            "class_counts": [
+              7,
+              5,
+              6
+            ],
+            "predicted_class_counts": [
+              8,
+              4,
+              6
+            ],
+            "confusion_matrix": [
+              [
+                5,
+                2,
+                0
+              ],
+              [
+                2,
+                2,
+                1
+              ],
+              [
+                1,
+                0,
+                5
+              ]
+            ],
+            "per_class_recall": [
+              0.7142857142857143,
+              0.4,
+              0.8333333333333334
+            ],
+            "balanced_accuracy": 0.6492063492063492,
+            "accuracy": 0.6666666666666666,
+            "weighted_f1": 0.6604938271604939,
+            "macro_f1": 0.6481481481481483,
+            "kappa": 0.49056603773584906
+          },
+          "reward": 0.6492063492063492,
+          "subjects": 18
+        },
+        "openbmi": {
+          "class_counts": [
+            2200,
+            2200
+          ],
+          "predicted_class_counts": [
+            1969,
+            2431
+          ],
+          "confusion_matrix": [
+            [
+              1637,
+              563
+            ],
+            [
+              332,
+              1868
+            ]
+          ],
+          "per_class_recall": [
+            0.7440909090909091,
+            0.8490909090909091
+          ],
+          "balanced_accuracy": 0.7965909090909091,
+          "accuracy": 0.7965909090909091,
+          "weighted_f1": 0.7960287132317542,
+          "macro_f1": 0.7960287132317541,
+          "kappa": 0.5931818181818183,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.8575,
+            "35": 0.96,
+            "34": 0.6425000000000001,
+            "51": 0.735,
+            "20": 0.79,
+            "44": 0.925,
+            "24": 0.58,
+            "15": 0.8925000000000001,
+            "31": 0.885,
+            "26": 0.8025,
+            "23": 0.6924999999999999
+          },
+          "reward": 0.796590909090909,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4511,
+            3907
+          ],
+          "confusion_matrix": [
+            [
+              3583,
+              677
+            ],
+            [
+              928,
+              3230
+            ]
+          ],
+          "per_class_recall": [
+            0.8410798122065728,
+            0.7768157768157768
+          ],
+          "balanced_accuracy": 0.8089477945111748,
+          "accuracy": 0.8093371347113328,
+          "weighted_f1": 0.8090983200093413,
+          "macro_f1": 0.8090012718037511,
+          "kappa": 0.618342456635853,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8230489841436236,
+            "sub-G2007": 0.7226128486994896,
+            "sub-G2019": 0.8258893699942211,
+            "sub-G2031": 0.7963056838653667,
+            "sub-G2015": 0.8526445481984531,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.7666994969943414,
+            "sub-G2035": 0.9409862780838013,
+            "sub-CTR003": 0.5660173160173161
+          },
+          "reward": 0.8097433109881833,
+          "subjects": 9
+        }
+      },
+      "losses": {
+        "faced": 1.3396710085868835,
+        "tuev": 0.788370543718338,
+        "ad65": 0.3727912467718124,
+        "openbmi": 0.4478912004828453,
+        "longitudinal": 0.23062818482518196
+      },
+      "seconds": 66.61602520942688
+    },
+    {
+      "epoch": 2,
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            161,
+            192,
+            162,
+            245,
+            249,
+            152,
+            174,
+            180,
+            165
+          ],
+          "confusion_matrix": [
+            [
+              79,
+              14,
+              6,
+              26,
+              19,
+              6,
+              10,
+              10,
+              10
+            ],
+            [
+              11,
+              80,
+              8,
+              21,
+              22,
+              9,
+              14,
+              6,
+              9
+            ],
+            [
+              8,
+              7,
+              88,
+              22,
+              17,
+              5,
+              7,
+              11,
+              15
+            ],
+            [
+              16,
+              20,
+              6,
+              73,
+              19,
+              8,
+              14,
+              17,
+              7
+            ],
+            [
+              14,
+              19,
+              13,
+              30,
+              109,
+              19,
+              12,
+              18,
+              6
+            ],
+            [
+              6,
+              11,
+              12,
+              20,
+              14,
+              79,
+              11,
+              13,
+              14
+            ],
+            [
+              9,
+              10,
+              8,
+              15,
+              18,
+              13,
+              89,
+              10,
+              8
+            ],
+            [
+              5,
+              16,
+              11,
+              22,
+              17,
+              10,
+              8,
+              85,
+              6
+            ],
+            [
+              13,
+              15,
+              10,
+              16,
+              14,
+              3,
+              9,
+              10,
+              90
+            ]
+          ],
+          "per_class_recall": [
+            0.4388888888888889,
+            0.4444444444444444,
+            0.4888888888888889,
+            0.40555555555555556,
+            0.45416666666666666,
+            0.4388888888888889,
+            0.49444444444444446,
+            0.4722222222222222,
+            0.5
+          ],
+          "balanced_accuracy": 0.45972222222222214,
+          "accuracy": 0.4595238095238095,
+          "weighted_f1": 0.4627178697155556,
+          "macro_f1": 0.4633441696694226,
+          "kappa": 0.3910565016406792,
+          "samples": 1680,
+          "reward": 0.45972222222222214,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            107,
+            622,
+            120,
+            177,
+            2165,
+            12296
+          ],
+          "confusion_matrix": [
+            [
+              31,
+              19,
+              10,
+              0,
+              0,
+              59
+            ],
+            [
+              0,
+              12,
+              0,
+              0,
+              279,
+              0
+            ],
+            [
+              10,
+              126,
+              0,
+              0,
+              533,
+              0
+            ],
+            [
+              0,
+              24,
+              0,
+              55,
+              0,
+              7
+            ],
+            [
+              0,
+              1,
+              1,
+              1,
+              468,
+              29
+            ],
+            [
+              66,
+              440,
+              109,
+              121,
+              885,
+              12201
+            ]
+          ],
+          "per_class_recall": [
+            0.2605042016806723,
+            0.041237113402061855,
+            0.0,
+            0.6395348837209303,
+            0.936,
+            0.8827231949066705
+          ],
+          "balanced_accuracy": 0.4599998989517225,
+          "accuracy": 0.8243688254665203,
+          "weighted_f1": 0.8501158634946686,
+          "macro_f1": 0.3340653161928278,
+          "kappa": 0.38522232593871697,
+          "samples": 15487,
+          "reward": 0.4599998989517225,
+          "subjects": 58
+        },
+        "ad65": {
+          "class_counts": [
+            464,
+            393,
+            486
+          ],
+          "predicted_class_counts": [
+            524,
+            331,
+            488
+          ],
+          "confusion_matrix": [
+            [
+              327,
+              110,
+              27
+            ],
+            [
+              135,
+              191,
+              67
+            ],
+            [
+              62,
+              30,
+              394
+            ]
+          ],
+          "per_class_recall": [
+            0.7047413793103449,
+            0.4860050890585242,
+            0.8106995884773662
+          ],
+          "balanced_accuracy": 0.6671486856154117,
+          "accuracy": 0.6790766939687267,
+          "weighted_f1": 0.6758667305200454,
+          "macro_f1": 0.6662008456092859,
+          "kappa": 0.5149154167316148,
+          "samples": 1343,
+          "subject_metrics": {
+            "class_counts": [
+              7,
+              5,
+              6
+            ],
+            "predicted_class_counts": [
+              8,
+              5,
+              5
+            ],
+            "confusion_matrix": [
+              [
+                5,
+                2,
+                0
+              ],
+              [
+                2,
+                3,
+                0
+              ],
+              [
+                1,
+                0,
+                5
+              ]
+            ],
+            "per_class_recall": [
+              0.7142857142857143,
+              0.6,
+              0.8333333333333334
+            ],
+            "balanced_accuracy": 0.7158730158730159,
+            "accuracy": 0.7222222222222222,
+            "weighted_f1": 0.7289562289562289,
+            "macro_f1": 0.7252525252525253,
+            "kappa": 0.5774647887323943
+          },
+          "reward": 0.7158730158730159,
+          "subjects": 18
+        },
+        "openbmi": {
+          "class_counts": [
+            2200,
+            2200
+          ],
+          "predicted_class_counts": [
+            1970,
+            2430
+          ],
+          "confusion_matrix": [
+            [
+              1640,
+              560
+            ],
+            [
+              330,
+              1870
+            ]
+          ],
+          "per_class_recall": [
+            0.7454545454545455,
+            0.85
+          ],
+          "balanced_accuracy": 0.7977272727272727,
+          "accuracy": 0.7977272727272727,
+          "weighted_f1": 0.7971730606875191,
+          "macro_f1": 0.7971730606875191,
+          "kappa": 0.5954545454545455,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.8625,
+            "35": 0.9550000000000001,
+            "34": 0.64,
+            "51": 0.7275,
+            "20": 0.8025,
+            "44": 0.9299999999999999,
+            "24": 0.58,
+            "15": 0.895,
+            "31": 0.8875,
+            "26": 0.7975000000000001,
+            "23": 0.6975
+          },
+          "reward": 0.7977272727272727,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4464,
+            3954
+          ],
+          "confusion_matrix": [
+            [
+              3574,
+              686
+            ],
+            [
+              890,
+              3268
+            ]
+          ],
+          "per_class_recall": [
+            0.8389671361502348,
+            0.785954785954786
+          ],
+          "balanced_accuracy": 0.8124609610525104,
+          "accuracy": 0.8127821335234022,
+          "weighted_f1": 0.8126169923801826,
+          "macro_f1": 0.8125344218085727,
+          "kappa": 0.6252891935659897,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.833632490611855,
+            "sub-G2007": 0.7304617356912722,
+            "sub-G2019": 0.8176766410930747,
+            "sub-G2031": 0.7973040680359799,
+            "sub-G2015": 0.8429774626319118,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.771485259745841,
+            "sub-G2035": 0.9467055869397201,
+            "sub-CTR003": 0.5882034632034632
+          },
+          "reward": 0.8135479978722395,
+          "subjects": 9
+        }
+      },
+      "losses": {
+        "faced": 1.3266721785068512,
+        "tuev": 0.7402228504419327,
+        "ad65": 0.36885406374931334,
+        "openbmi": 0.44960359126329424,
+        "longitudinal": 0.22761556178331374
+      },
+      "seconds": 85.07392573356628
+    }
+  ],
+  "parameters": 6868247
+}

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

@@ -0,0 +1,187 @@
+{
+  "schema": "bci-shared-biot-covariance-bf16head-v1",
+  "architecture": {
+    "channels": 32,
+    "width": 128,
+    "depth": 2,
+    "dropout": 0.5,
+    "wave_filters": 32
+  },
+  "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/hybrid_biot_csp_bf16head/epoch-001",
+    "source_weights_sha256": "68bc5b4b986520fa912f362a76830c2c5b8cad628a52af9421680276944a1216",
+    "shared_backbone_unchanged": true,
+    "selected_head_epochs": {
+      "faced": 0,
+      "tuev": 0,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 16
+    }
+  }
+}

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

@@ -0,0 +1,192 @@
+{
+  "schema": "bci-shared-biot-covariance-bf16head-v1",
+  "architecture": {
+    "channels": 32,
+    "width": 128,
+    "depth": 2,
+    "dropout": 0.5,
+    "wave_filters": 32
+  },
+  "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/hybrid_biot_csp_bf16head/epoch-001",
+    "source_weights_sha256": "68bc5b4b986520fa912f362a76830c2c5b8cad628a52af9421680276944a1216",
+    "shared_backbone_unchanged": true,
+    "selected_head_epochs": {
+      "faced": 0,
+      "tuev": 0,
+      "ad65": 0,
+      "openbmi": 0,
+      "longitudinal": 16
+    }
+  },
+  "clinical_spectral_refinement": {
+    "source": "/workspace/research/runs/head_dropout1/epoch-016",
+    "zero_initialized_input_adapter": true,
+    "backbone_unchanged": true
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S011/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/S011/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/S011/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/S011/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/S011/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/S011/training.json

@@ -0,0 +1,2530 @@
+{
+  "history": [
+    {
+      "epoch": 7,
+      "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": [
+            594,
+            724,
+            187,
+            475,
+            1457,
+            12050
+          ],
+          "confusion_matrix": [
+            [
+              21,
+              38,
+              23,
+              4,
+              0,
+              33
+            ],
+            [
+              0,
+              224,
+              0,
+              39,
+              28,
+              0
+            ],
+            [
+              115,
+              154,
+              120,
+              55,
+              225,
+              0
+            ],
+            [
+              5,
+              0,
+              0,
+              80,
+              0,
+              1
+            ],
+            [
+              2,
+              0,
+              1,
+              24,
+              422,
+              51
+            ],
+            [
+              451,
+              308,
+              43,
+              273,
+              782,
+              11965
+            ]
+          ],
+          "per_class_recall": [
+            0.17647058823529413,
+            0.7697594501718213,
+            0.17937219730941703,
+            0.9302325581395349,
+            0.844,
+            0.8656489654174504
+          ],
+          "balanced_accuracy": 0.6275806265455862,
+          "accuracy": 0.8285658939755924,
+          "weighted_f1": 0.8618635180906945,
+          "macro_f1": 0.40367911279847074,
+          "kappa": 0.42983741832596223,
+          "samples": 15487,
+          "reward": 0.6275806265455862,
+          "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
+        }
+      },
+      "clinical_training_loss": 0.6892783784866333
+    }
+  ],
+  "settings": {
+    "source": "/workspace/research/runs/head_dropout1/epoch-016",
+    "cache": "/workspace/research/clinical_fusion_v1",
+    "output": "/workspace/research/runs/clinical_spectral_adapter1",
+    "epochs": 30,
+    "steps": 100,
+    "batch_size": 128,
+    "lr": 0.0001,
+    "head_lr": 1e-05,
+    "retention": 1.0,
+    "seed": 7
+  },
+  "parent_training_receipt": {
+    "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
+  },
+  "shared_backbone_training": "inherited joint training on all five training splits; fixed during input-adapter/head refinement",
+  "updated_parameters": [
+    "adapters.tuev.spectral",
+    "heads.tuev"
+  ],
+  "initialization_maximum_logit_error": 0.0,
+  "training_target_provenance": {
+    "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
+  }
+}

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

@@ -0,0 +1,214 @@
+{
+  "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
+  },
+  "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
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S018/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/S018/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/S018/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/S018/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/S018/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/S018/model.py

@@ -0,0 +1,134 @@
+"""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
+
+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):
+        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)
+        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)
+    def spectral_features(self,features):
+        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)
+        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 forward(self,x,features,covariance_features):
+        return self.signal(x).unsqueeze(1),self.spectral_features(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,clinical_asymmetry=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") 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/S023/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/S023/config.json

@@ -0,0 +1,615 @@
+{
+  "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": 1,
+      "ad65": 0,
+      "openbmi": 10,
+      "longitudinal": 2
+    }
+  },
+  "private_track_selection": {
+    "track": "tuev",
+    "donor": "/workspace/research/replicates/frequency_head_control1/epoch-001"
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S023/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/S023/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/S023/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/S023/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/S023/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/S023/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/S023/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/S023/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/S024/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/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/S027/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/S030/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/S030/config.json

@@ -0,0 +1,669 @@
+{
+  "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
+  },
+  "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
+    }
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S030/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/S030/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/S030/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/S030/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/S030/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/S030/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/S030/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/S030/model.py

@@ -0,0 +1,222 @@
+"""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 TemporalEvidenceHead(nn.Module):
+    """Pool class evidence over the shared waveform time axis."""
+    def __init__(self,prior,channels=64,temperature=.25):
+        super().__init__();self.prior=prior;self.channels=channels;self.temperature=temperature
+        self.register_buffer('evidence_output_scale',torch.ones(()))
+        self.register_buffer('evidence_mean',torch.zeros(channels))
+        self.register_buffer('evidence_scale',torch.ones(channels))
+        self.evidence_projection=nn.Linear(channels,prior.prior.base.out_features,bias=False)
+        nn.init.zeros_(self.evidence_projection.weight)
+    def patches(self,x):
+        with torch.autocast(x.device.type,enabled=False):
+            wave=x[:,:-512].float().reshape(len(x),self.channels,-1).transpose(1,2)
+            return ((wave-self.evidence_mean)/self.evidence_scale).clamp(-8,8)
+    def evidence(self,patches):
+        with torch.autocast(patches.device.type,enabled=False):
+            values=self.evidence_projection(patches.float())/self.temperature
+            maximum=values.amax(1,keepdim=True)
+            pooled=self.temperature*((values-maximum).exp().mean(1).log()+maximum.squeeze(1))
+            return self.evidence_output_scale*pooled
+    def forward(self,x):
+        prior=self.prior(x)
+        return prior+self.evidence(self.patches(x)).to(prior.dtype)
+
+class FourierResidualHead(nn.Module):
+    """A fixed random Fourier basis and trainable linear classifier correction."""
+    def __init__(self,prior,features,classes,basis=256):
+        super().__init__();self.prior=prior
+        self.register_buffer('rff_mean',torch.zeros(features));self.register_buffer('rff_scale',torch.ones(features))
+        self.register_buffer('rff_frequency',torch.randn(features,basis)/features**.5)
+        self.register_buffer('rff_phase',torch.rand(basis)*2*torch.pi)
+        self.register_buffer('rff_output_scale',torch.ones(()))
+        self.rff_projection=nn.Linear(3*basis,classes);nn.init.zeros_(self.rff_projection.weight);nn.init.zeros_(self.rff_projection.bias)
+    def basis(self,x):
+        with torch.autocast(x.device.type,enabled=False):
+            values=((x.float()-self.rff_mean)/self.rff_scale).clamp(-8,8)@self.rff_frequency
+            return 2**.5*torch.cat([(values/sigma+self.rff_phase).cos() for sigma in (.5,1.,2.)],-1)
+    def forward(self,x):
+        prior=self.prior(x)
+        with torch.autocast(x.device.type,enabled=False):added=self.rff_output_scale*self.rff_projection(self.basis(x))
+        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,temporal_evidence=False,evidence_temperature=.25,random_fourier=False,fourier_features=256):
+        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()})
+        if temporal_evidence:self.heads=nn.ModuleDict({t:TemporalEvidenceHead(head,wave_filters*2,evidence_temperature) for t,head in self.heads.items()})
+        if random_fourier:self.heads=nn.ModuleDict({t:FourierResidualHead(head,2*wave_filters*(((SPECS[t][1]*200+1)//4+1)//8)+width+256+width,SPECS[t][2],fourier_features) 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/S031/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/S031/config.json

@@ -0,0 +1,669 @@
+{
+  "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
+  },
+  "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
+    }
+  }
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/submissions/S031/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)
+