Add files using upload-large-folder tool

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/evaluations/S036/reward.json

@@ -0,0 +1,7 @@
+{
+  "faced": 0.48081052066559316,
+  "tuev": 0.6391058442293831,
+  "ad65": 0.6126984126984126,
+  "openbmi": 0.7790909090909092,
+  "longitudinal": 0.7649947533498158
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/evaluations/S047/reward.json

@@ -0,0 +1,7 @@
+{
+  "faced": 0.4800053676865271,
+  "tuev": 0.6301147498183727,
+  "ad65": 0.6126984126984126,
+  "openbmi": 0.7793181818181818,
+  "longitudinal": 0.7649978993280152
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/evaluations/S074/reward.json

@@ -0,0 +1,7 @@
+{
+  "faced": 0.5120772946859904,
+  "tuev": 0.6281560533875664,
+  "ad65": 0.6126984126984126,
+  "openbmi": 0.7838636363636364,
+  "longitudinal": 0.78453205361538
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/evaluations/S089/reward.json

@@ -0,0 +1,7 @@
+{
+  "faced": 0.5099302200751477,
+  "tuev": 0.6278724740352559,
+  "ad65": 0.6126984126984126,
+  "openbmi": 0.7836363636363636,
+  "longitudinal": 0.7897014070181297
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/evaluations/S104/reward.json

@@ -0,0 +1,7 @@
+{
+  "faced": 0.5099302200751477,
+  "tuev": 0.6283807134818248,
+  "ad65": 0.6126984126984126,
+  "openbmi": 0.7859090909090909,
+  "longitudinal": 0.7896589718302767
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/prompt.txt

@@ -0,0 +1,10 @@
+It is now time to submit. Stop exploring the problem. Submit your best solution without further experiments. You will be given an additional 5 minutes starting now to submit.
+The 48-hour research budget is over. This is a separate, hard-limited submission-only window.
+Use only code, weights, observations, and development results you already produced.
+Do not train, run inference/evaluations/simulations, search hyperparameters, or conduct any new experiment.
+Choose using only your existing research notes and results; no sealed evaluation results are available.
+Publish a complete portable package to /workspace/submission using the original task contract.
+The original research tree is now read-only. Use /workspace/finalization or /tmp for packaging scratch;
+/workspace/submission and its local parent support atomic publication. File listing, copying,
+archiving, and static checks needed for packaging are allowed. Do not alter the scientific method.
+The previous container's processes have ended. Finish and stop after publishing. Do not inspect credentials.

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/publication-review.json

@@ -0,0 +1,105 @@
+{
+  "reviewed_utc": "2026-11-02T22:34:08.498207+00:00",
+  "task": "brain-computer-interface-decoding",
+  "research_run": "brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a (native 1 H100 budget, nineteenth task)",
+  "result_label": "48h-plus-5m-submission-only",
+  "accepted_as_48h_result": false,
+  "thread_verified": true,
+  "same_original_thread": true,
+  "thread_id": "01a19351-dcd4-7b31-83ad-611e1e0b6c67",
+  "all_new_command_executions_reviewed": true,
+  "publication_seconds": 160.55633218679577,
+  "research_seconds": 172800,
+  "no_new_experiments": true,
+  "no_new_experiments_basis": "passed: every new command reviewed; items 2-7 and 10-11 read published_state.json, the contract, the installed-closure proof record, infer.sh, requirements, config keys, MODEL_CARD.md, the baseline publish.py and device ids; item 9 writes finalize_submission.py, copies the recorded source package into /workspace/finalization, verifies all 47 file hashes, ast/json/bash -n syntax and permissions, then fails with EXDEV on renameat2 RENAME_EXCHANGE against the image-layer submission directory, so the live package was never replaced; item 12 re-hashes the live package (47 files identical to the proof closure) and writes a receipt under /workspace/finalization. infer.sh/infer.py were never executed; no training, inference, evaluation or simulation ran.",
+  "commands": [
+    {
+      "item_id": "item_2",
+      "command": "/bin/sh -lc pwd",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_3",
+      "command": "/bin/sh -lc 'cat /workspace/research/published_state.json'",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_4",
+      "command": "/bin/sh -lc 'cat /workspace/contract.md'",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_5",
+      "command": "/bin/sh -lc \"python - <<'PY'\nimport json,os\np='/workspace/research/published_state.json'\nx=json.load(open(p))\nprint('published_state_keys',list(x))\nfor k,v in x.items():\n if isinstance(v,(str,int,float,bool)) or v is None: print(k, v)\nprint('submission_exists',os.path.isdir('/workspace/submission'))\nprint('submission_files',sorted(os.listdir('/workspace/submission')))\np='/workspace/research/publication-fb1405db77c9-installed-closure.json'\nx=json.load(open(p)); print('closure_keys',list(x)); print('file_count',len(x.get('all_package_file_sha256',{})))\nPY\"",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_6",
+      "command": "/bin/sh -lc 'cat /workspace/contract.md'",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_7",
+      "command": "/bin/sh -lc \"python - <<'PY'\nimport json,pathlib,hashlib\nr=pathlib.Path('/workspace/submission')\nfor n in ['infer.sh','requirements.txt']:\n print(n); print((r/n).read_text())\nx=json.loads((r/'config.json').read_text()); print('config_keys',list(x)); print('model_card', (r/'MODEL_CARD.md').read_text()[:5500])\np=pathlib.Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nprint('closure_sha256',hashlib.sha256(p.read_bytes()).hexdigest())\nx=json.loads(p.read_text()); print('scores',x.get('installed_scores')); print('source',x.get('source')); print('recorded_pass',x.get('direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'))\nPY\"",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_9",
+      "command": "/bin/sh -lc \"mkdir -p /workspace/finalization\ncat > /workspace/finalization/finalize_submission.py <<'PY'\nimport ast\nimport ctypes\nimport datetime\nimport hashlib\nimport json\nimport os\nfrom pathlib import Path\nimport shutil\nimport subprocess\n\nroot = Path('/workspace/finalization')\nclosure_path = Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nclosure_bytes = closure_path.read_bytes()\nclosure_hash = hashlib.sha256(closure_bytes).hexdigest()\nassert closure_hash == '3f70e7cb494d2d93fa03460c2dea5de85d2d47c141948aba1db7a690e4a431db'\nclosure = json.loads(closure_bytes)\nexpected = closure['all_package_file_sha256']\nassert len(expected) == 47\nsource = Path(closure['source'])\nassert source == Path('/workspace/research/experiments543/all_full/epoch-008')\nassert closure['direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'] is True\nstate = json.loads(Path('/workspace/research/published_state.json').read_text())\nassert state['source'] == str(source)\nassert state['weights_sha256'] == closure['weights_sha256']\nassert state['verification_status'] == 'complete'\nsubmission = Path('/workspace/submission')\nassert submission.is_dir() and not submission.is_symlink()\nstamp = datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%dT%H%M%SZ')\nstage = root / ('package543-' + stamp)\nassert not stage.exists()\n\nlibc = ctypes.CDLL(None, use_errno=True)\nexchange = libc.renameat2\nexchange.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]\nexchange.restype = ctypes.c_int\nassert root.stat().st_dev == submission.parent.stat().st_dev\n\ndef audit_files(folder):\n    actual = {}\n    for path in sorted(folder.rglob('*')):\n        assert not path.is_symlink(), str(path)\n        if path.is_dir():\n            continue\n        assert path.is_file(), str(path)\n        name = path.relative_to(folder).as_posix()\n        h = hashlib.sha256()\n        with path.open('rb') as stream:\n            for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b''):\n                h.update(chunk)\n        actual[name] = h.hexdigest()\n    assert set(actual) == set(expected), (set(actual) - set(expected), set(expected) - set(actual))\n    assert actual == expected, [name for name in actual if actual[name] \"'!= expected[name]]\n    return actual\n\nshutil.copytree(source, stage, symlinks=True)\naudit_files(stage)\nfor path in stage.glob('\"'*.py'):\n    ast.parse(path.read_text(), filename=path.name)\nfor path in stage.glob('*.json'):\n    json.loads(path.read_text())\nsubprocess.run(['bash', '-n', str(stage / 'infer.sh')], check=True)\nassert (stage / 'weights.pt').stat().st_size > 0\nassert expected['weights.pt'] == 'fb1405db77c975a547acc95ca50fd8113aa42134a9b52b167843e4fa442ee61e'\nfor path in stage.rglob('*'):\n    if path.is_file():\n        assert path.stat().st_mode & 0o004, 'File must be readable by inference user: ' + str(path)\nassert stage.stat().st_mode & 0o005 == 0o005\nprint('Staged package matches all 47 recorded file hashes; static syntax and permissions pass.', flush=True)\nif exchange(-100, os.fsencode(stage), -100, os.fsencode(submission), 2) \"'!= 0:\n    error = ctypes.get_errno()\n    raise OSError(error, os.strerror(error))\ninstalled = audit_files(submission)\nreceipt = {\n    '\"'completed_at': datetime.datetime.now(datetime.timezone.utc).isoformat(),\n    'submission': str(submission),\n    'selected_existing_source': str(source),\n    'weights_sha256': closure['weights_sha256'],\n    'existing_proof_closure': str(closure_path),\n    'existing_proof_closure_sha256': closure_hash,\n    'selection_validation_scores_from_existing_records': closure['installed_scores'],\n    'atomic_publication': 'renameat2 RENAME_EXCHANGE',\n    'all_47_installed_package_hashes_match_existing_proof': True,\n    'all_package_file_sha256': installed,\n    'finalization_checks': ['file inventory and no symlinks', 'SHA256 hashes', 'Python AST syntax', 'JSON syntax', 'bash -n syntax', 'unprivileged read permissions'],\n    'new_training_inference_evaluation_or_experiments': False,\n    'previous_submission_backup': str(stage),\n}\nreceipt_path = root / 'submission-finalization.json'\nreceipt_path.write_text(json.dumps(receipt, indent=2) + '\\\\n')\nprint('Published /workspace/submission atomically; all 47 installed hashes match.')\nprint('Finalization receipt: ' + str(receipt_path))\nprint('Weights SHA256: ' + closure['weights_sha256'])\nPY\npython /workspace/finalization/finalize_submission.py\"",
+      "exit_code": 1
+    },
+    {
+      "item_id": "item_10",
+      "command": "/bin/sh -lc 'cat /workspace/baseline/braindecode/publish.py'",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_11",
+      "command": "/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nimport os\nfor name in ['/workspace','/workspace/submission','/workspace/finalization']:\n p=Path(name); print(name,'real',p.resolve(),'device',p.stat().st_dev,'mount',os.path.ismount(p))\nprint('stages',list(Path('/workspace/finalization').glob('package543-*')))\nPY\"",
+      "exit_code": 0
+    },
+    {
+      "item_id": "item_12",
+      "command": "/bin/sh -lc \"python - <<'PY'\nimport ast, datetime, hashlib, json, os, subprocess\nfrom pathlib import Path\nroot=Path('/workspace/finalization')\nproof=Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nproof_hash=hashlib.sha256(proof.read_bytes()).hexdigest()\nassert proof_hash=='3f70e7cb494d2d93fa03460c2dea5de85d2d47c141948aba1db7a690e4a431db'\nclosure=json.loads(proof.read_text())\nexpected=closure['all_package_file_sha256']\npackage=Path('/workspace/submission')\nassert package.is_dir() and not package.is_symlink()\nactual={}\nfor path in sorted(package.rglob('*')):\n assert not path.is_symlink(), str(path)\n if path.is_dir():\n  assert path.stat().st_mode & 0o005 == 0o005\n  continue\n assert path.is_file() and path.stat().st_mode & 0o004\n h=hashlib.sha256()\n with path.open('rb') as stream:\n  for chunk in iter(lambda: stream.read(8*1024*1024),b''): h.update(chunk)\n actual[path.relative_to(package).as_posix()]=h.hexdigest()\nassert actual==expected\nassert len(actual)==47\nassert package.stat().st_mode & 0o005 == 0o005\nfor path in package.glob('*.py'): ast.parse(path.read_text(),filename=path.name)\nfor path in package.glob('*.json'): json.loads(path.read_text())\nsubprocess.run(['bash','-n',str(package/'infer.sh')],check=True)\nreceipt={\n 'completed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),\n 'submission':str(package),\n 'selected_existing_source':closure['source'],\n 'weights_sha256':closure['weights_sha256'],\n 'existing_proof_closure':str(proof),\n 'existing_proof_closure_sha256':proof_hash,\n 'publication_action':'Retained the already published complete package, byte-identical to the selected proof-closed source.',\n 'existing_atomic_publication_and_all_checks_recorded_before_finalization':closure['direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'],\n 'staging_note':'A fresh copy matched all 47 archived hashes. Atomic exchange returned EXDEV on the image-layer submission directory, leaving the already published submission unchanged. Static verification confirmed the installed package is exactly the selected candidate.',\n 'all_47_installed_package_hashes_match_existing_proof':True,\n 'all_package_file_sha256':actual,\n 'selection_validation_scores_from_existing_records':closure['installed_scores'],\n 'finalization_checks':['file inventory','no symlinks','SHA256 hashes','Python AST syntax','JSON syntax','bash -n syntax','unprivileged read permissions'],\n 'new_training_inference_evaluation_or_experiments':False,\n}\np=root/'submission-finalization.json'\np.write_text(json.dumps(receipt,indent=2)+'\\\\n')\nprint('FINALIZED /workspace/submission: all 47 package files match the existing verified experiment 543 package.')\nprint('Weights SHA256:',closure['weights_sha256'])\nprint('Receipt:',p)\nprint('No training, inference, evaluation, simulation, or experiment was run during finalization.')\nPY\"",
+      "exit_code": 0
+    }
+  ],
+  "harmless_stderr": [
+    "item 9 renameat2 EXDEV: the overlay submission directory cannot be exchanged; the package stayed unchanged and the staged copy remained outside the package"
+  ],
+  "publication_retry": null,
+  "submission_sha256": "e22ea9d334a7923cdf1cda3cfca1ff6bd0fce78f592a0b63b219334648686e14",
+  "package_sha256": "e22ea9d334a7923cdf1cda3cfca1ff6bd0fce78f592a0b63b219334648686e14",
+  "cutoff_package_sha256": "e22ea9d334a7923cdf1cda3cfca1ff6bd0fce78f592a0b63b219334648686e14",
+  "package_changed": false,
+  "package_diff": {
+    "added": [],
+    "changed": [],
+    "removed": []
+  },
+  "package_diff_detail": {
+    "added": [],
+    "removed": [],
+    "changed": [],
+    "n_files_final": 47,
+    "n_files_window": 47
+  },
+  "package_checks": "submission sha equals the 48h cutoff sha e22ea9d334a7 (snapshot 147381, campaign S127); inference footprint of all 47 files identical; boundary preflight PUBLICATION_BOUNDARY_OK",
+  "inference_files_and_modes_unchanged": true,
+  "verifier_metadata_unchanged": true,
+  "verifier_metadata": {},
+  "publication_helper_check": "Agent-written finalize_submission.py: hashing, ast/json/bash -n checks and a renameat2 exchange that failed with EXDEV before touching the live package; the baseline publish.py was only read.",
+  "equivalent_snapshot": "S127",
+  "same_inference_candidate_as": "S127",
+  "inference_key": "reviewed-inference-v1:9fd1f0002e7c9029861009fc7733df3c85e81ce00a71b5815dc9cc0a38666b8f",
+  "evaluation_decision": "reuse_existing_score",
+  "new_evaluation_queued": false,
+  "additional_evaluation_required": false,
+  "evaluation_root": "/weka/oe-adapt-default/stevenc/science-speedrun-runs/brain-computer-interface-decoding-astra-native-eval-s127-20261031a",
+  "score_source": "/weka/oe-adapt-default/stevenc/science-speedrun-runs/brain-computer-interface-decoding-astra-native-eval-s127-20261031a/results/reward.json",
+  "score_status_at_review": "S127 complete; five track rewards {'faced': 0.504428341384863, 'tuev': 0.634790635182636, 'ad65': 0.6126984126984126, 'openbmi': 0.786818181818182, 'longitudinal': 0.7919118451349597} (no scalar aggregate by task design)",
+  "original_48h_history_unchanged": true,
+  "original_results_preserved": true,
+  "trajectory_sha256": "a128c143465fa4805d3022dcc6d0776f1e2d762dc56070ca50f7ebcd10bd972f",
+  "successful_publication_job": "01M6EYCYZVHE90380JM89DCETZ"
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/status.json

@@ -0,0 +1,19 @@
+{
+  "phase": "complete",
+  "error": null,
+  "elapsed_seconds": 160.55633218679577,
+  "total_publication_seconds": 160.55633218679577,
+  "thread_id": "01a19351-dcd4-7b31-83ad-611e1e0b6c67",
+  "turn_completed": true,
+  "submission_sha256": "e22ea9d334a7923cdf1cda3cfca1ff6bd0fce78f592a0b63b219334648686e14",
+  "cutoff_submission_sha256": "e22ea9d334a7923cdf1cda3cfca1ff6bd0fce78f592a0b63b219334648686e14",
+  "package_changed": false,
+  "result_label": "48h-plus-5m-submission-only",
+  "accepted_as_48h_result": false,
+  "no_experiments_review": "passed",
+  "original_results_preserved": true,
+  "publication_review": "/weka/oe-adapt-default/stevenc/science-speedrun-runs/brain-computer-interface-decoding-astra-finalize-5m-20261102a/publication-review.json",
+  "evaluation_identity": "reviewed-inference-v1:9fd1f0002e7c9029861009fc7733df3c85e81ce00a71b5815dc9cc0a38666b8f",
+  "additional_evaluation_required": false,
+  "same_inference_candidate_as": "S127"
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/MODEL_CARD.md

@@ -0,0 +1,103 @@
+# Shared EEG decoder
+
+This package contains one coupled backbone used by all five tracks, with private input adapters and classifiers. Every trainable common component was trained with all five training splits. It is a single model; inference performs no parameter updates or dataset-level fitting.
+
+The common backbone combines waveform convolutions, an audited pretrained BIOT feature path, covariance and log-correlation encoders, and shared feature corrections. The waveform coactivation extension encodes 64 within-window log variances and 2,016 correlations between common waveform channels. A matched experimental control removes the correlation inputs. `config.json` identifies the packaged variant and its five fixed correction gains. All original backbone parameters are fixed during this extension's joint training.
+
+Weights originate only from the supplied training data and audited initialization checkpoints. Training details, parent provenance, raw/cache checks, shared-gradient checks and the five separate validation metrics are recorded in `training.json`. Validation selects checkpoints and fixed gains; it does not fit normalization or update parameters. Reported validation results belong to selected checkpoints, not to private test evaluation or five-seed means.
+
+Run `bash infer.sh INPUT_DIR OUTPUT_DIR`. The input manifest specifies a track and opaque sample IDs, shard paths and indices. Signals are in microvolts and are scaled by 1/100. The package writes one probability vector per input ID to `OUTPUT_DIR/predictions.jsonl`. It needs only the packaged files and the contract's installed Python dependencies, works after relocation, and does not need labels, subject IDs, training caches or network access.
+
+FACED and TUEV use window balanced accuracy. AD65 uses mean window probabilities per patient before balanced accuracy. OpenBMI averages within-subject balanced accuracy. Longitudinal averages within-session balanced accuracy within each subject, then over subjects. These five metrics remain separate.
+
+This checkpoint adds fixed within-window ordinal pattern probabilities, permutation entropy and statistical complexity at five delays. Training-only normalization and five input projections feed one common correction MLP trained by all five tracks. The common correction enters the existing covariance and fusion representations; fixed per-track gains select its strength. All earlier model tensors remain unchanged.
+
+Fixed real and imaginary spectral coherence between the inherited 24 spatial filters is normalized using training windows only and encoded by one new common network. Five private linear heads add class evidence. All five training splits update the new common encoder; all earlier model tensors remain unchanged.
+
+Fixed per-window relative band powers, envelope variability, envelope correlations and phase-amplitude coupling feed training-normalized private input projections and one new shared encoder. Five linear heads add class evidence. All five training splits update the new common encoder; all prior model tensors remain unchanged. AD65 updates use all windows from six class-balanced training patients; objective: mean-probability.
+
+The inherited OpenBMI phase-classifier projection was refreshed from a separately validated private-readout fit. Every common tensor and input adapter of this jointly trained model is unchanged. Exact ancestor checks confirm that all common tensors used by this inherited readout are identical; the new cross-frequency correction remains disabled for OpenBMI. No shared checkpoints or predictions are ensembled.
+
+A common CBraMod feature encoder, itself jointly trained on all five training splits, supplies its shared summary and tokens pooled into four ordered time bins. Its classifiers are discarded. A new common feature MLP and five zero-initialized private linear projections learn residual class evidence jointly on all five training splits. Training may randomly remove the earlier decoder logits for half of training groups, using one mask per AD patient and one per other window; labels and teacher targets remain unchanged. Validation and inference always retain the complete earlier decoder. The same new class projection also receives an auxiliary standalone classification loss when configured, with the same patient-pooled AD objective; this adds no inference module. The complete earlier decoder and feature extractor remain tensor-identical; selecting zero residual gain preserves its predictions exactly. The summary-only control masks the 8192 ordered features after training-fitted per-feature normalization. One feature backbone and one classifier per track run at inference, with no prediction ensemble or external runtime cache.
+
+The five outer private student-feature class projections are refined on all five training splits while every common/input/prior-head tensor remains exactly fixed. AD uses the exact patient-mean probability objective. Private checkpoints may be selected independently only because the common representation is identical; all five metrics are evaluated for every exported package.
+
+The longitudinal private outer projection is selected from another training-only readout fit using exactly the same common/input/prior-head tensors. All other private heads are retained. Exact equality of every common tensor and executable runtime is audited; this package has one common checkpoint and one head per track.
+
+The complete stronger parent is retained, including its common CBraMod feature encoder, common readout and all private classifiers. The CBraMod features and existing common128-dimensional embedding are computed once and reused. An additional common128-to256-to128 MLP with the configured GELU or identity activation and five zero-initialized private linear projections learn residual class evidence jointly on all five training splits. Training may randomly remove the earlier decoder logits for half of training groups, using one mask per AD patient and one per other window; labels and teacher targets remain unchanged. Validation and inference always retain the complete earlier decoder. The same new class projection also receives an auxiliary standalone classification loss when configured, with the same patient-pooled AD objective; this adds no inference module. The complete earlier decoder and feature extractor remain tensor-identical; selecting zero residual gain preserves its predictions exactly. One feature backbone and one classifier per track run at inference, with no prediction ensemble or external runtime cache.
+
+The five outer private student-feature class projections are refined on all five training splits while every common/input/prior-head tensor remains exactly fixed. AD uses the exact patient-mean probability objective. Private checkpoints may be selected independently only because the common representation is identical; all five metrics are evaluated for every exported package.
+
+The openbmi private outer projection is selected from another training-only readout fit using exactly the same common/input/prior-head tensors. All other private heads are retained. Exact equality of every common tensor and executable runtime is audited; this package has one common checkpoint and one head per track.
+
+A fixed two-second crop supplies spectral and cross-frequency coupling features, with no short-window envelope autocorrelation. The crop is configured as center or first. Each track has a training-fitted normalizer and linear input adapter to128 dimensions; one common128-to256-to128 GELU/LayerNorm block and five zero-initialized class projections are jointly trained on all five training splits. All complete-parent tensors are preserved exactly. Normalization statistics use training windows only. The parent is randomly removed from the training loss at the configured probability; it is always present at inference. AD uses mean patient probabilities over all sampled patient windows. Auxiliary classification uses the same class projection. There is one composed feature backbone and head per track; no prediction ensemble, external runtime cache, test adaptation, or evaluation-metadata features. Zero residual gain exactly retains the complete parent.
+
+The five outer private center-context class projections are refined on all five training splits while every common/input/prior-head tensor remains exactly fixed. AD uses the exact patient-mean probability objective. Private checkpoints may be selected independently only because the common representation is identical; all five metrics are evaluated for every exported package.
+
+The tuev private outer projection is selected from another training-only readout fit using exactly the same common/input/prior-head tensors. All other private heads are retained. Exact equality of every common tensor and executable runtime is audited; this package has one common checkpoint and one head per track.
+
+The faced private context input and outer class projections are selected from another training-only readout fit using exactly the same common/oldinput/normalizer/prior-head tensors. All other private input/head pairs are retained. Exact equality of every common tensor and executable runtime is audited; this package has one common checkpoint and one head per track.
+
+A fixed one-second crop supplies spectral and cross-frequency coupling features, with no short-window envelope autocorrelation. The crop is configured as center or first. Each track has a training-fitted normalizer and linear input adapter to128 dimensions; one common128-to256-to128 GELU/LayerNorm block and five zero-initialized class projections are jointly trained on all five training splits. All complete-parent tensors are preserved exactly. Normalization statistics use training windows only. The parent is randomly removed from the training loss at the configured probability; it is always present at inference. AD uses mean patient probabilities over all sampled patient windows. Auxiliary classification uses the same class projection. There is one composed feature backbone and head per track; no prediction ensemble, external runtime cache, test adaptation, or evaluation-metadata features. Zero residual gain exactly retains the complete parent.
+
+The five outer private short-context class projections are refined on all five training splits while every common/input/prior-head tensor remains exactly fixed. AD uses the exact patient-mean probability objective. Private checkpoints may be selected independently only because the common representation is identical; all five metrics are evaluated for every exported package.
+
+The tuev private outer projection is selected from another training-only readout fit using exactly the same common/input/prior-head tensors. All other private heads are retained. Exact equality of every common tensor and executable runtime is audited; this package has one common checkpoint and one head per track.
+
+An additional common context block preserves every existing short-context parent tensor and correction. A fixed one-second crop supplies spectral and cross-frequency coupling features, with no short-window envelope autocorrelation. TUEV concatenates first and center one-second descriptors; the parameter-matched control repeats first descriptors. Other tracks use first one-second descriptors. Each track has a training-fitted normalizer and linear input adapter to128 dimensions; one common128-to256-to128 GELU/LayerNorm block and five zero-initialized class projections are jointly trained on all five training splits. All complete-parent tensors are preserved exactly. Normalization statistics use training windows only. The parent is randomly removed from the training loss at the configured probability; it is always present at inference. AD uses mean patient probabilities over all sampled patient windows. Auxiliary classification uses the same class projection. There is one composed feature backbone and head per track; no prediction ensemble, external runtime cache, test adaptation, or evaluation-metadata features. Zero residual gain exactly retains the complete parent.
+
+An additional shared128-to256-to128 GELU/LayerNorm block is jointly trained by all five tracks. OpenBMI uses seven native-channel trace-normalized covariance matrices with fixed5percent identity shrinkage: matrix-log upper triangles in the main arm, covariance-minus-identity in the matched control. Other four new inputs are first-one-second spectral/coupling descriptors. Every complete-parent tensor is preserved exactly. Input normalization uses training windows only; zero outer gain retains the parent. Five private adapters and class projections, one composed shared backbone, no evaluation adaptation or external runtime cache.
+
+The five outer private geometry-block input adapters and class projections are refined on all five training splits. Every common backbone, fitted normalizer and earlier input/prior-head tensor remains exactly fixed. Common parameters are excluded from optimization; differentiable evaluation of the fixed common block permits gradients to the private input maps. AD uses the exact patient-mean probability objective. Private input/head checkpoints may be selected independently only because the common parameter state is identical and every track uses its own private adapter/head; all five metrics are evaluated for every exported package.
+
+An additional shared128-to256-to128 GELU/LayerNorm block is jointly trained by all five tracks. FACED uses seven native-channel trace-normalized covariance matrices with fixed5percent identity shrinkage: matrix-log upper triangles in the main arm, covariance-minus-identity in the matched control. Other four new inputs are first-one-second spectral/coupling descriptors. Every complete-parent tensor is preserved exactly. Input normalization uses training windows only; zero outer gain retains the parent. Five private adapters and class projections, one composed shared backbone, no evaluation adaptation or external runtime cache.
+
+The longitudinal private context input and outer class projections are selected from another training-only readout fit using exactly the same common/oldinput/normalizer/prior-head tensors. All other private input/head pairs are retained. Exact equality of every common tensor and executable runtime is audited; this package has one common checkpoint and one head per track.
+
+An additional shared128-to256-to128 gelu/LayerNorm block is jointly trained by all five tracks. FACED uses seven native-channel trace-normalized covariance matrices with fixed5percent identity shrinkage and matrix-log upper triangles in both activation conditions. Other four new inputs are first-one-second spectral/coupling descriptors. Every complete-parent tensor is preserved exactly. Input normalization uses training windows only; zero outer gain retains the parent. Five private adapters and class projections, one composed shared backbone, no evaluation adaptation or external runtime cache.
+
+The five outer private refinement-block input adapters and class projections are refined on all five training splits. Every common backbone, fitted normalizer and earlier input/prior-head tensor remains exactly fixed. Common parameters are excluded from optimization; differentiable evaluation of the fixed common block permits gradients to the private input maps. AD uses the exact patient-mean probability objective. Private input/head checkpoints may be selected independently only because the common parameter state is identical and every track uses its own private adapter/head; all five metrics are evaluated for every exported package.
+
+The five outer private refinement-block input adapters and class projections are refined on all five training splits. Every common backbone, fitted normalizer and earlier input/prior-head tensor remains exactly fixed. Common parameters are excluded from optimization; differentiable evaluation of the fixed common block permits gradients to the private input maps. AD uses the exact patient-mean probability objective. Private input/head checkpoints may be selected independently only because the common parameter state is identical and every track uses its own private adapter/head; all five metrics are evaluated for every exported package.
+
+An additional shared128-to256-to128 gelu/LayerNorm block is jointly trained by all five tracks. OpenBMI uses full-window spectral and cross-frequency features from six central/parietal local differences or the matched six native channels under common-average reference. FACED retains native log covariance descriptors; TUEV/AD65/Longitudinal retain first1s descriptors. Both conditions have identical parameter dimensions. Every complete-parent tensor is preserved exactly. Input normalization uses training windows only; zero outer gain retains the parent. Five private adapters and class projections, one composed shared backbone, no evaluation adaptation or external runtime cache.
+
+The five outer private spatial-block input adapters and class projections are refined on all five training splits. Every common backbone, fitted normalizer and earlier input/prior-head tensor remains exactly fixed. Common parameters are excluded from optimization; differentiable evaluation of the fixed common block permits gradients to the private input maps. AD uses the exact patient-mean probability objective. Private input/head checkpoints may be selected independently only because the common parameter state is identical and every track uses its own private adapter/head; all five metrics are evaluated for every exported package.
+
+The five outer private spatial-block input adapters and class projections are refined on all five training splits. Every common backbone, fitted normalizer and earlier input/prior-head tensor remains exactly fixed. Common parameters are excluded from optimization; differentiable evaluation of the fixed common block permits gradients to the private input maps. AD uses the exact patient-mean probability objective. Private input/head checkpoints may be selected independently only because the common parameter state is identical and every track uses its own private adapter/head; all five metrics are evaluated for every exported package.
+
+A widened shared256-to512-to256 dense GELU block with two LayerNorm groups is jointly trained by all five tracks. Matching complete input/common representations are transferred from two audited all-five-trained ancestors, then dense cross-half connections train without task routing. Each track has one 256-to-class projection. This is a newly jointly trained common architecture. TUEV uses952conditional partial ormatchedmarginal nativebipolar covariance descriptors; theotherfour fixeddescriptors retain the completeparent spatial-feature recipe. Bothconditions haveidentical dimensions. Every completeparent tensor ispreserved; normalizationusestrainingwindowsonly. Onecomposedsharedbackbone, fiveprivateadapters/classheads, noevaluationadaptation/externalcache.
+
+Five outer private scalar gains were selected from a bounded fifteen-value grid on the provided validation splits. Every trained common backbone, input adapter, classifier and earlier gain remains exactly unchanged. This is additional model selection on the same validation people, not an independent test result. Inference uses fixed selected gains and no adaptation.
+
+The complete coherent selected1166-state model is jointly continued on all five training splits with fixed source gains, fresh AdamW, and main-gradient-protected standalone auxiliary supervision. Every1118-state earlier parent remains exact. The current conditional common encoder, five private input maps and heads update together. Source gains remain eligible during finite validation selection; no inference adaptation.
+
+Only the FACED outer private input adapter and class projection use learning rate1e-6; the common encoder and other four private inputs/heads use1e-7. Every track jointly trains the same common parameter set. The optimizer has two disjoint exhaustive groups and the original shared cosine schedule, global clipping, AdamW betas and decay.
+
+The five outer private conditional-block input adapters and class projections are refined on all five training splits. Every common backbone, fitted normalizer and earlier input/prior-head tensor remains exactly fixed. Common parameters are excluded from optimization; differentiable evaluation of the fixed common block permits gradients to the private input maps. AD uses the exact patient-mean probability objective. Private input/head checkpoints may be selected independently only because the common parameter state is identical and every track uses its own private adapter/head; all five metrics are evaluated for every exported package.
+
+The openbmi outer private input map and classifier are selected from a separately trained private fit with every common, normalizer and prior tensor exactly identical. The other four private pairs remain from the reference package. There is one shared backbone and one classifier per track. Both donor training stages are replayed and the combined package is checked directly on all five validation splits.
+
+The faced outer private input map and classifier are selected from a separately trained private fit with every common, normalizer and prior tensor exactly identical. The other four private pairs remain from the reference package. There is one shared backbone and one classifier per track. Both donor training stages are replayed and the combined package is checked directly on all five validation splits.
+
+One shared confidence encoder transforms fixed per-window entropy and probability margin from the frozen earlier prior. Five private scalar projections modulate the existing conditional residual by a bounded multiplier in [0.75,1.25]. Every1166 existing source state stays fixed and the old conditional encoder remains in eval mode during fitting. All five training splits update the new shared confidence encoder and their private scalar gates. Confidence gate enabled=1.0. All source1166 states initialize exactly. Native head addition precision is preserved. No evaluation adaptation or external inference cache.
+
+The final private confidence gates are selected between their trained values and exact zero at the single final shared checkpoint. All five original outer gains are restored to the verified source values. All1166 original model states remain exact; the six new common confidence parameters retain their joint all-five training. Zero private gates restore each track's original function independently of the new common weights. This construction performs no additional training or validation-input adaptation. Selected gates on: {"ad65": false, "faced": false, "longitudinal": false, "openbmi": true, "tuev": false}.
+
+A new common descriptor encoder is trained jointly on all five tracks, with five input adapters and new class projections. OpenBMI uses multitaper native covariance; the other four use the source conditional descriptors. All 1183 source states are fixed. Normalizers use 8192 matched TRAIN-only draws per track; no evaluation adaptation. New class weights initialize to zero. Validation selects private gains within one complete new common checkpoint, with exact source fallback at zero. The new addition uses float32 over complete source336 logits. Current enabled=1.0.
+
+A new common descriptor encoder is trained jointly on all five tracks, with five input adapters and new class projections. FACED, OpenBMI and Longitudinal use weighted amplitude-weighted ordinal pattern features; TUEV and AD65 reuse existing source descriptor inputs. All 1232 source states are fixed. Normalizers use 8192 matched TRAIN-only draws per track; no evaluation adaptation. New class weights initialize to zero. Validation selects private gains within one complete new common checkpoint, with exact source fallback at zero. The new addition uses float32 over complete source374 logits. Current enabled=1.0.
+
+Seven Gaussian spectral filters feed one new common encoder trained jointly on all five tracks, with five input adapters and class projections. Filter centers and widths are shared across all tracks; their training learning rate is 0.0. All 1281 source states remain fixed. Per-window Welch log-relative spectra use fixed preprocessing, and new normalizers fit only 8192 balanced TRAIN draws per track at the initial filter parameters. No evaluation adaptation. New class weights initialize to zero. Validation selects private gains within one complete common checkpoint, with exact complete388 fallback at zero. All additions use float32. Current enabled=1.0.
+
+Two shared nonlinear feature blocks are trained jointly on all five tracks over the existing weighted ordinal and clinical/dementia descriptors. Both shared blocks are evaluated for every input; bounded softmax routing keeps both weights positive. Routing mode is input. Five private input maps, task biases and class heads accompany the common blocks and router. All 1333 source states and inherited TRAIN-only normalization statistics remain fixed. New class weights initialize to zero. Validation chooses private gains within one complete common checkpoint, with exact complete431 fallback at zero. There is no evaluation adaptation or cross-checkpoint head combination. Current enabled=1.0.
+
+A new shared 128/256/128 nonlinear block is jointly trained on all five tracks above the complete verified 443 source. Longitudinal alone receives the fixed TRAIN-fitted strong descriptor geometry licensed by screen 458; its map is square. All four maps have the same expanded width and five per-track input projections and class heads. All 1386 source states stay fixed. The 25 Longitudinal geometry buffers use only TRAIN statistics. Other input normalizers are inherited unchanged. New class heads initialize at zero. Validation selects private gains within one common checkpoint, with exact complete443 fallback at zero. No inference adaptation or cross-common-checkpoint head combination. Current enabled=1.0.
+
+One new shared spectral projection and two shared content-attention blocks are trained jointly on all five tracks above the complete verified459 square source. Five private channel positions and reused TRAIN spectrum normalizers accompany zero-initialized correction heads and normally initialized auxiliary heads. Readout mode: detached. Separate routes auxiliary gradients through its own readout into the shared encoder; coupled uses the correction readout for both objectives; detached blocks auxiliary gradients to the encoder. All conditions have identical parameters and shapes. All1450 source states stay fixed. Validation selects private correction gains inside one complete common checkpoint. No evaluation adaptation, external inference caches, or cross-checkpoint head combination. Enabled=1.0.
+
+A fresh shared temporal-basis CNN is trained jointly on all five complete TRAIN splits with native label supervision, five private montage maps and classifiers. The complete source remains frozen. Per-track validation selects a declared logit blend within this whole common checkpoint. No evaluation adaptation or external inference caches. Temporal coefficient mode: absolute.
+
+A fresh shared CNN with a fixed temporal dilation bank and private channel maps is trained jointly on all five complete TRAIN splits with native label supervision, five private montage maps and classifiers. The complete source remains frozen. Per-track validation selects a declared logit blend within this whole common checkpoint. No evaluation adaptation or external inference caches. Temporal dilation mode: local.
+
+A fresh shared CNN with fixed internal activation-normalization groups and one forward pass is trained jointly on all five complete TRAIN splits with native label supervision, five private montage maps and classifiers. The complete source remains frozen. Per-track validation selects a declared logit blend within this whole common checkpoint. No evaluation adaptation or external inference caches. Fixed common normalization-group mode: all.

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/activation_groups_math.py

@@ -0,0 +1,14 @@
+"""Fixed group counts for the three common CNN activation normalizers."""
+GROUPS = {'all': (1, 1, 1), 'two': (2, 2, 2), 'original': (4, 8, 8)}
+MODES = tuple(GROUPS)
+
+
+def configure_groups(block, mode):
+    assert mode in GROUPS
+    for name, channels, groups in zip(('norm_temporal', 'norm_spatial', 'norm_separable'),
+                                      (16, 32, 64), GROUPS[mode]):
+        layer = getattr(block, name)
+        assert layer.num_channels == channels and layer.eps == 1e-5
+        assert layer.affine and channels % groups == 0
+        layer.num_groups = groups
+    return block

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/additive_hinge_features.py

@@ -0,0 +1,29 @@
+"""459 portable Longitudinal strong descriptors, with fixed 32-row arithmetic."""
+import torch
+from features import extract_features
+from coupling_features import coupling_features
+from short_context_features import short_spectral_features
+from native_log_covariance_features import connectivity
+from weighted_ordinal_features import weighted_ordinal_features
+BLOCK_DIMENSIONS={'full':20039,'center2':20039,'first1':20039,'log_covariance':11977,'weighted_base':7540}
+BLOCK_WEIGHTS={'full':.3375,'center2':.11249999999999999,'first1':.11249999999999999,'log_covariance':.1875,'weighted_base':.25}
+RAW_DIMENSION=sum(BLOCK_DIMENSIONS.values())
+PROJECTED_DIMENSION=6*RAW_DIMENSION
+
+@torch.no_grad()
+def longitudinal_hinge_features(raw):
+    assert raw.ndim==4 and tuple(raw.shape[1:])==(58,2,200)
+    old=torch.backends.cuda.matmul.allow_tf32
+    try:
+        torch.backends.cuda.matmul.allow_tf32=False
+        with torch.autocast(raw.device.type,enabled=False):
+            results=[]
+            for start in range(0,len(raw),32):
+                x=raw[start:start+32].float();n=len(x)
+                if n<32:x=torch.cat([x,x.new_zeros((32-n,*x.shape[1:]))])
+                flat=x.flatten(2)
+                values=[torch.cat([extract_features('longitudinal',x),coupling_features('longitudinal',x)],-1),torch.cat([short_spectral_features('longitudinal',flat),coupling_features('longitudinal',flat)],-1),torch.cat([short_spectral_features('longitudinal',flat[...,:200]),coupling_features('longitudinal',flat[...,:200])],-1),connectivity('longitudinal',x,True),weighted_ordinal_features('longitudinal',x)['weighted']]
+                assert [v.shape[1] for v in values]==list(BLOCK_DIMENSIONS.values())
+                results.append(torch.cat(values,-1)[:n])
+            return torch.cat(results,0) if results else raw.new_empty((0,RAW_DIMENSION),dtype=torch.float32)
+    finally:torch.backends.cuda.matmul.allow_tf32=old

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/additive_hinge_geometry.py

@@ -0,0 +1,60 @@
+"""459 fixed TRAIN-fitted coordinate geometry; no inference adaptation."""
+import math
+import numpy as np
+import torch
+from torch import nn
+from additive_hinge_features import BLOCK_DIMENSIONS,BLOCK_WEIGHTS,PROJECTED_DIMENSION
+from additive_hinge_kernel import basis
+MODES=('hinge','rotated','square','linear')
+
+class AdditiveBlock(nn.Module):
+    def __init__(self,dimension,mode):
+        super().__init__();assert mode in MODES;self.mode=mode;self.dimension=dimension
+        self.register_buffer('mean',torch.zeros(dimension,dtype=torch.float64))
+        self.register_buffer('scale',torch.ones(dimension,dtype=torch.float64))
+        self.register_buffer('basis_mean',torch.zeros(5*dimension,dtype=torch.float64))
+        self.register_buffer('trace_factor',torch.ones((),dtype=torch.float64))
+        self.register_buffer('permutation',torch.tensor(np.random.default_rng(458000+dimension).permutation(dimension),dtype=torch.int64))
+    def normalized(self,values):return ((values.double()-self.mean)/self.scale).clamp(-8,8)
+    def rotate(self,values):
+        result=values[:,self.permutation].clone();even=self.dimension//2*2
+        pairs=result[:,:even].reshape(len(values),-1,2);a,b=pairs[:,:,0].clone(),pairs[:,:,1].clone()
+        pairs[:,:,0]=(a+b)/(2**.5);pairs[:,:,1]=(a-b)/(2**.5)
+        return result
+    def mapped(self,values):
+        value=basis(values,self.mode)
+        return value if self.mode in ('hinge','rotated') else value.repeat_interleave(5,dim=1)
+    @torch.no_grad()
+    def fit(self,raw):
+        assert raw.ndim==2 and raw.shape[1]==self.dimension and len(raw)>1
+        raw=raw.double();self.mean.copy_(raw.mean(0));self.scale.copy_(raw.std(0,correction=0).clamp_min(.001))
+        values=self.normalized(raw);target=(values-values.mean(0)).square().sum(1).mean()/self.dimension
+        rotated=self.rotate(values) if self.mode=='rotated' else values
+        trace=values.new_zeros(())
+        for start in range(0,self.dimension,256):
+            phi=self.mapped(rotated[:,start:start+256]);mean=phi.mean(0);self.basis_mean[start*5:(start+256)*5].copy_(mean)
+            trace+=(phi-mean).square().sum(1).mean()/(5*self.dimension)
+        self.trace_factor.copy_(target/trace.clamp_min(1e-20))
+        assert torch.isfinite(self.trace_factor) and self.trace_factor>=0
+    def forward(self,raw,weight):
+        x=self.normalized(raw);rotated=self.rotate(x) if self.mode=='rotated' else x
+        phi=self.mapped(rotated)-self.basis_mean
+        return x*math.sqrt(.75*weight/self.dimension),phi*(.25*weight*self.trace_factor/(5*self.dimension)).sqrt()
+
+class AdditiveGeometry(nn.Module):
+    def __init__(self,mode):
+        super().__init__();self.blocks=nn.ModuleDict({key:AdditiveBlock(d,mode) for key,d in BLOCK_DIMENSIONS.items()})
+    @torch.no_grad()
+    def fit(self,raw):
+        offset=0
+        for key,block in self.blocks.items():
+            block.fit(raw[:,offset:offset+block.dimension]);offset+=block.dimension
+        assert offset==raw.shape[1]
+    def forward(self,raw,return_double=False):
+        pieces=[];offset=0
+        for key,block in self.blocks.items():
+            pieces.extend(block(raw[:,offset:offset+block.dimension],BLOCK_WEIGHTS[key]));offset+=block.dimension
+        assert offset==raw.shape[1]
+        result=torch.cat(pieces,1)*math.sqrt(PROJECTED_DIMENSION)
+        assert result.shape[1]==PROJECTED_DIMENSION
+        return result if return_double else result.float()

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

@@ -0,0 +1,47 @@
+"""Standalone shared CNN with explicit temporal response coefficients.
+
+No pretrained source, trained state, dataset, split or training recipe is
+selected here. A separately bound study is required before EEG fitting.
+"""
+from torch import nn
+from torch.nn import functional as F
+from temporal_convolution_math import SharedTemporalConvolution, precise_convolution, raw_convolution_features
+from learned_filter_temporal_basis import pool_filter_trajectories, MODES
+
+TRACKS = ('faced', 'tuev', 'ad65', 'openbmi', 'longitudinal')
+SPECS = {'faced': (32, 9), 'tuev': (16, 6), 'ad65': (19, 3),
+         'openbmi': (62, 2), 'longitudinal': (58, 2)}
+
+
+class TemporalBasisConvolution(SharedTemporalConvolution):
+    def __init__(self, pooling_mode='signed'):
+        assert pooling_mode in MODES
+        super().__init__()
+        self.pooling_mode = pooling_mode
+        self.embedding = nn.Linear(384, 128)
+
+    def forward(self, x):
+        x = self.norm_temporal(self.temporal(x.unsqueeze(1)))
+        x = self.dropout_spatial(F.avg_pool2d(F.elu(self.norm_spatial(self.spatial(x))), (1, 4)))
+        x = self.dropout_separable(F.avg_pool2d(F.elu(self.norm_separable(self.pointwise(self.depthwise(x)))), (1, 8)))
+        x = pool_filter_trajectories(x.squeeze(2), self.pooling_mode)
+        return self.dropout_embedding(self.norm_embedding(F.gelu(self.embedding(x))))
+
+
+class TemporalBasisModel(nn.Module):
+    def __init__(self, pooling_mode='signed'):
+        super().__init__()
+        self.adapters = nn.ModuleDict({track: nn.Linear(SPECS[track][0], 16, bias=False) for track in TRACKS})
+        self.backbone = TemporalBasisConvolution(pooling_mode)
+        self.heads = nn.ModuleDict({track: nn.Linear(128, SPECS[track][1]) for track in TRACKS})
+        for head in self.heads.values():
+            nn.init.normal_(head.weight, std=.02)
+            nn.init.zeros_(head.bias)
+
+    def forward_features(self, track, preprocessed):
+        with precise_convolution(preprocessed.device.type):
+            x = self.adapters[track](preprocessed.float().transpose(1, 2)).transpose(1, 2)
+            return self.heads[track](self.backbone(x))
+
+    def forward(self, track, raw):
+        return self.forward_features(track, raw_convolution_features(track, raw, 'raw'))

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/channel_attention_math.py

@@ -0,0 +1,56 @@
+"""466 shared channel attention; all modes use the same primitive shapes."""
+import math
+import torch
+from torch import nn
+MODES = ('content', 'uniform', 'self')
+
+def attention_weights(scores, mode):
+    if mode == 'content':
+        return scores.softmax(-1)
+    if mode == 'uniform':
+        return (scores * 0.).softmax(-1)
+    if mode == 'self':
+        return torch.eye(scores.shape[-1], device=scores.device, dtype=scores.dtype) + scores * 0.
+    raise ValueError(mode)
+
+class ChannelAttentionBlock(nn.Module):
+    def __init__(self, mode):
+        super().__init__()
+        assert mode in MODES
+        self.mode = mode
+        self.norm1 = nn.LayerNorm(128)
+        self.qkv = nn.Linear(128, 384)
+        self.output = nn.Linear(128, 128)
+        self.dropout_attention = nn.Dropout(.3)
+        self.norm2 = nn.LayerNorm(128)
+        self.ff1 = nn.Linear(128, 256)
+        self.gelu = nn.GELU()
+        self.dropout_hidden = nn.Dropout(.3)
+        self.ff2 = nn.Linear(256, 128)
+        self.dropout_output = nn.Dropout(.3)
+
+    def forward(self, tokens):
+        batch, channels, _ = tokens.shape
+        qkv = self.qkv(self.norm1(tokens)).reshape(batch, channels, 3, 4, 32).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv.unbind(0)
+        weights = attention_weights(q @ k.transpose(-1, -2) / math.sqrt(32), self.mode)
+        context = (weights @ v).transpose(1, 2).reshape(batch, channels, 128)
+        tokens = tokens + self.dropout_attention(self.output(context))
+        hidden = self.dropout_hidden(self.gelu(self.ff1(self.norm2(tokens))))
+        return tokens + self.dropout_output(self.ff2(hidden))
+
+class SharedChannelAttention(nn.Module):
+    def __init__(self, mode):
+        super().__init__()
+        self.input = nn.Linear(95, 128)
+        self.blocks = nn.ModuleList([ChannelAttentionBlock(mode) for _ in range(2)])
+        self.final_norm = nn.LayerNorm(128)
+
+    def forward_tokens(self, spectra, position):
+        tokens = self.input(spectra) + position
+        for block in self.blocks:
+            tokens = block(tokens)
+        return self.final_norm(tokens)
+
+    def forward(self, spectra, position):
+        return self.forward_tokens(spectra, position).mean(1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/confidence_model.py

@@ -0,0 +1,46 @@
+"""One shared confidence encoder modulates the existing residual readout per window."""
+import math
+from legacy_model import *
+LegacyHybridModel=HybridModel
+
+def confidence_features(prior,scale):
+    with torch.autocast(prior.device.type,enabled=False):
+        probability=(prior.detach().float()/scale).softmax(-1)
+        entropy=-(probability*probability.clamp_min(1e-12).log()).sum(-1)/math.log(probability.shape[-1])
+        top=probability.topk(2,dim=-1).values;margin=top[:,0]-top[:,1]
+        return torch.stack([entropy,entropy.square(),margin,margin.square()],-1)
+
+class ConfidenceEncoder(nn.Module):
+    def __init__(self,enabled):
+        super().__init__();self.net=nn.Sequential(nn.Linear(4,16),nn.GELU(),nn.Linear(16,16),nn.LayerNorm(16))
+        self.register_buffer('enabled',torch.tensor(float(enabled)))
+    def forward(self,x):return self.net(x)
+
+class ConfidenceReadoutHead(nn.Module):
+    def __init__(self,old,encoder):
+        super().__init__();self.prior=old.prior;self.width=old.width;self.projection=old.projection
+        self.register_buffer('output_scale',old.output_scale);self.register_buffer('correction_gain',old.correction_gain)
+        self.confidence_projection=nn.Linear(16,1);nn.init.zeros_(self.confidence_projection.weight);nn.init.zeros_(self.confidence_projection.bias)
+        # The backbone owns and registers this ONE encoder; all five heads reference it.
+        object.__setattr__(self,'_confidence_encoder',encoder)
+    def gated_logits(self,prior,embedding):
+        with torch.autocast(prior.device.type,enabled=False):
+            logits=self.projection(embedding.float());encoder=self._confidence_encoder
+            hidden=encoder(confidence_features(prior,self.output_scale));modulation=self.confidence_projection(hidden).tanh()
+            multiplier=1.+encoder.enabled*.25*modulation
+            return logits*multiplier
+    def predict_from_prior(self,prior,embedding,gain=None,return_standalone=False):
+        with torch.autocast(prior.device.type,enabled=False):
+            standalone=self.gated_logits(prior,embedding);gain=self.correction_gain if gain is None else gain
+            delta=(gain*self.output_scale)*standalone;result=prior+delta.to(prior.dtype)
+        return (result,standalone) if return_standalone else result
+    def forward(self,values):
+        prior=self.prior(values[:,:-self.width]);return self.predict_from_prior(prior,values[:,-self.width:])
+
+class HybridModel(LegacyHybridModel):
+    def __init__(self,confidence_gating=False,confidence_gate_enabled=1.,**kwargs):
+        super().__init__(**kwargs);self.confidence_gating=confidence_gating
+        if confidence_gating:
+            with torch.random.fork_rng(devices=[]):
+                self.backbone.confidence_encoder=ConfidenceEncoder(confidence_gate_enabled)
+                self.heads=nn.ModuleDict({t:ConfidenceReadoutHead(head,self.backbone.confidence_encoder) for t,head in self.heads.items()})

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/coupling_features.py

@@ -0,0 +1,34 @@
+"""Per-window cross-frequency envelope and phase-amplitude relationships."""
+import torch
+BANDS=((1,4),(4,8),(8,13),(13,30),(30,48))
+PAIRS=tuple((i,j) for i in range(5) for j in range(i+1,5))
+PER_CHANNEL=30
+
+@torch.no_grad()
+def coupling_features(track,x):
+    with torch.autocast(x.device.type,enabled=False):
+        x=torch.nan_to_num(x.float().flatten(2),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)
+        x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+        n=x.shape[-1];spectrum=torch.fft.fft(x,dim=-1);frequency=torch.fft.fftfreq(n,1/200,device=x.device)
+        masks=torch.stack([2*((frequency>=lo)&(frequency<hi)).float() for lo,hi in BANDS])
+        analytic=torch.fft.ifft(spectrum[:,:,None]*masks[None,None],dim=-1)
+        amplitude=analytic.abs();unit_phase=analytic/amplitude.clamp_min(1e-3)
+        weight=torch.hann_window(n,device=x.device);weight=weight/weight.sum()
+        mean=(amplitude*weight).sum(-1);centered=amplitude-mean[...,None]
+        variance=(centered.square()*weight).sum(-1)
+        # Relative and absolute floors avoid normalizing numerical silence after unit-RMS scaling.
+        deviation=variance.sqrt()
+        stable_deviation=torch.maximum(deviation,.01*mean).clamp_min(1e-3)
+        normalized=centered/stable_deviation[...,None]
+        power=(amplitude.square()*weight).sum(-1)
+        relative=(power/power.sum(-1,keepdim=True).clamp_min(1e-12)).clamp_min(1e-6).log()
+        cv=(deviation/mean.clamp_min(1e-3)).clamp(0,10)
+        envelopes=[];phase_amplitude=[]
+        for low,high in PAIRS:
+            correlation=(normalized[:,:,low]*normalized[:,:,high]*weight).sum(-1)
+            envelopes.append(torch.atanh(correlation.clamp(-.999,.999)))
+            coupling=(normalized[:,:,high]*unit_phase[:,:,low]*weight).sum(-1).abs()
+            phase_amplitude.append(coupling.clamp(0,.999))
+        return torch.cat([relative,cv,torch.stack(envelopes,-1),torch.stack(phase_amplitude,-1)],-1).flatten(1)

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

@@ -0,0 +1,19 @@
+"""Protect the main objective using the actual combined mixed-precision gradient."""
+import torch
+
+def protect_group(total,main,strength):
+    assert strength in (0.,1.) and len(total)==len(main)>0
+    assert all(a.shape==b.shape and a.device==b.device and torch.isfinite(a).all() and torch.isfinite(b).all() for a,b in zip(total,main))
+    g=torch.cat([v.detach().double().flatten() for v in total]);m=torch.cat([v.detach().double().flatten() for v in main])
+    main_squared=torch.dot(m,m);dot=torch.dot(g-m,m);conflict=bool(main_squared>0 and dot<0);coefficient=float(-dot/main_squared) if conflict else 0.
+    before=float(torch.dot(g,m));original_norm=float(g.norm())
+    if strength and conflict:
+        offset=0;updated=g+coefficient*m
+        with torch.no_grad():
+            for target in total:
+                size=target.numel();target.copy_(updated[offset:offset+size].reshape_as(target).to(target.dtype));offset+=size
+    after=sum(float(torch.dot(a.detach().double().flatten(),b.detach().double().flatten())) for a,b in zip(total,main))
+    rounding_relative=max(1e-6,2*max(torch.finfo(v.dtype).eps for v in total))
+    tolerance=rounding_relative*max(float(main_squared),abs(before),abs(after),1e-30)
+    if strength:assert after>=float(main_squared)-tolerance,(after,float(main_squared),before,coefficient)
+    return {'main_squared_norm':float(main_squared),'effective_auxiliary_main_dot':float(dot),'conflict':conflict,'applied':bool(strength and conflict),'coefficient':coefficient if strength else 0.,'total_main_dot_before':before,'total_main_dot_after':after,'total_norm_before':original_norm,'total_norm_after':float(torch.cat([v.detach().double().flatten() for v in total]).norm())}

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

@@ -0,0 +1,592 @@
+from student_features import CBraModFeatures,FrequencyAdapter
+"""One fused waveform/spectral backbone used identically by all five tasks."""
+import torch
+from torch import nn
+MOTOR_CHANNELS=('Fp1', 'Fp2', 'F7', 'F3', 'Fz', 'F4', 'F8', 'FC5', 'FC1', 'FC2', 'FC6', 'T7', 'C3', 'Cz', 'C4', 'T8', 'TP9', 'CP5', 'CP1', 'CP2', 'CP6', 'TP10', 'P7', 'P3', 'Pz', 'P4', 'P8', 'PO9', 'O1', 'Oz', 'O2', 'PO10', 'FC3', 'FC4', 'C5', 'C1', 'C2', 'C6', 'CP3', 'CPz', 'CP4', 'P1', 'P2', 'POz', 'FT9', 'FTT9h', 'TTP7h', 'TP7', 'TPP9h', 'FT10', 'FTT10h', 'TPP8h', 'TP8', 'TPP10h', 'F9', 'F10', 'AF7', 'AF3', 'AF4', 'AF8', 'PO3', 'PO4')
+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
+from tangent_features import extract_tangent_features,TANGENT_DIM
+from phase_features import phase_features,PHASE_DIM,PHASE_HALF
+from coupling_features import coupling_features,PER_CHANNEL as COUPLING_PER_CHANNEL
+from ordinal_features import ordinal_features,PER_CHANNEL as ORDINAL_PER_CHANNEL
+
+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.ordinal_normalizer=Standardize(c*ORDINAL_PER_CHANNEL)
+        self.ordinal_projection=nn.Linear(c*ORDINAL_PER_CHANNEL,width)
+        self.ordinal_dropout=nn.Dropout(.3)
+        self.register_buffer('ordinal_probabilities_enabled',torch.ones(()))
+        self.coupling_normalizer=Standardize(c*COUPLING_PER_CHANNEL)
+        self.coupling_projection=nn.Linear(c*COUPLING_PER_CHANNEL,width)
+        self.coupling_dropout=nn.Dropout(.3)
+        self.register_buffer('coupling_dependence_enabled',torch.ones(()))
+        self.phase_normalizer=Standardize(PHASE_DIM)
+        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 coupling_embedding(self,features):
+        values=self.coupling_normalizer(features).reshape(len(features),-1,COUPLING_PER_CHANNEL)
+        values=torch.cat([values[...,:10],self.coupling_dependence_enabled*values[...,10:]],-1).flatten(1)
+        return self.coupling_projection(self.coupling_dropout(values))
+    def ordinal_embedding(self,features):
+        values=self.ordinal_normalizer(features).reshape(len(features),-1,5,26)
+        values=torch.cat([self.ordinal_probabilities_enabled*values[...,:24],values[...,24:]],-1).flatten(1)
+        return self.ordinal_projection(self.ordinal_dropout(values))
+    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.phase_encoder=nn.Sequential(nn.LayerNorm(PHASE_DIM),nn.Linear(PHASE_DIM,width),nn.GELU(),nn.Dropout(.3),Residual(width,.3),nn.LayerNorm(width))
+        self.register_buffer('phase_imaginary_enabled',torch.ones(()))
+        self.coupling_encoder=nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width*2),nn.GELU(),nn.Dropout(.3),nn.Linear(width*2,width),nn.LayerNorm(width))
+        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)
+        self.tangent_encoder=nn.Sequential(nn.LayerNorm(TANGENT_DIM),nn.Linear(TANGENT_DIM,width),nn.GELU(),nn.Dropout(.3),Residual(width,.3),nn.LayerNorm(width),nn.Linear(width,width))
+        self.ordinal_context=nn.Sequential(nn.LayerNorm(width),nn.Linear(width,width*2),nn.GELU(),nn.Dropout(.3),nn.Linear(width*2,width))
+        nn.init.zeros_(self.ordinal_context[-1].weight);nn.init.zeros_(self.ordinal_context[-1].bias)
+        self.register_buffer('codebrain_enabled',torch.ones(()))
+        self.codebrain_patch_encoder=nn.Sequential(nn.LayerNorm(24*64),nn.Linear(24*64,width),nn.GELU(),nn.Dropout(.3))
+        self.codebrain_context=nn.Sequential(nn.LayerNorm(width*4),nn.Linear(width*4,width*2),nn.GELU(),nn.Dropout(.3),nn.Linear(width*2,width))
+        nn.init.zeros_(self.codebrain_context[-1].weight);nn.init.zeros_(self.codebrain_context[-1].bias)
+    def codebrain_correction(self,tokens,representation,fusion_input):
+        with torch.autocast(tokens.device.type,enabled=False):
+            encoded=self.codebrain_patch_encoder(self.codebrain_enabled*tokens.float())
+            pooled=torch.cat([encoded.mean(1),encoded.std(1,correction=0),representation[:,-512:-384].float(),representation[:,-128:].float()],-1)
+            delta=self.codebrain_context(pooled)
+        added=.001*nn.functional.linear(delta,self.covariance_projection.weight,None)
+        corrected=self.fusion(fusion_input+added.to(fusion_input.dtype))
+        return corrected-representation[:,-512:-384],delta
+    def forward(self,signal,spectral,neural_signal,covariance_features,tangent_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)
+        with torch.autocast(signal.device.type,enabled=False):delta=self.tangent_encoder(tangent_features.float())
+        added=.001*nn.functional.linear(delta,self.covariance_projection.weight,None)
+        corrected=self.fusion((original+coupled)+added.to(original.dtype))
+        return torch.cat([wave.flatten(1),fused,neural,covariance_embedding],-1),corrected-fused,delta,original+coupled
+
+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 TangentFeatureHead(nn.Module):
+    """Select a shared feature correction before the inherited classifier."""
+    def __init__(self,prior):
+        super().__init__();self.prior=prior;self.feature_gain=nn.Parameter(torch.zeros(()))
+    def forward(self,values):
+        old=values[:,:-256];fusion_delta=values[:,-256:-128];covariance_delta=values[:,-128:]
+        adjusted=torch.cat([old[:,:-512],old[:,-512:-384]+self.feature_gain*fusion_delta,old[:,-384:-128],old[:,-128:]+self.feature_gain*covariance_delta],-1)
+        return self.prior(adjusted)
+
+class CodeBrainFeatureHead(nn.Module):
+    """Private use of a jointly trained common feature correction."""
+    def __init__(self,prior):
+        super().__init__();self.prior=prior;self.codebrain_gain=nn.Parameter(torch.ones(()))
+    def forward(self,values):
+        previous=values[:,:-256];native=previous[:,:-256]
+        fusion_delta=values[:,-256:-128];covariance_delta=values[:,-128:]
+        adjusted=torch.cat([native[:,:-512],native[:,-512:-384]+self.codebrain_gain*fusion_delta,native[:,-384:-128],native[:,-128:]+self.codebrain_gain*covariance_delta],-1)
+        return self.prior(torch.cat([adjusted,previous[:,-256:]],-1))
+
+class WaveCoactivationContext(nn.Module):
+    """One common encoder of coactivation among the learned waveform channels."""
+    def __init__(self,channels=64,width=128):
+        super().__init__();self.channels=channels
+        ii,jj=torch.triu_indices(channels,channels,offset=1)
+        self.register_buffer('pair_i',ii);self.register_buffer('pair_j',jj)
+        self.register_buffer('offdiagonal_enabled',torch.ones(()))
+        self.encoder=nn.Sequential(nn.LayerNorm(channels+len(ii)),nn.Linear(channels+len(ii),width),nn.GELU(),nn.Dropout(.3),Residual(width,.3),nn.LayerNorm(width))
+    def statistics(self,native):
+        with torch.autocast(native.device.type,enabled=False):
+            wave=native[:,:-512].float().reshape(len(native),self.channels,-1)
+            centered=wave-wave.mean(-1,keepdim=True)
+            previous_tf32=torch.backends.cuda.matmul.allow_tf32
+            torch.backends.cuda.matmul.allow_tf32=False
+            covariance=centered@centered.transpose(-1,-2)/wave.shape[-1]
+            torch.backends.cuda.matmul.allow_tf32=previous_tf32
+            variance=covariance.diagonal(dim1=-2,dim2=-1).clamp_min(1e-8)
+            correlation=covariance/(variance.sqrt()[:,:,None]*variance.sqrt()[:,None,:])
+            return torch.cat([variance.log(),correlation[:,self.pair_i,self.pair_j].clamp(-1,1)],-1)
+    def encode_statistics(self,values):
+        with torch.autocast(values.device.type,enabled=False):
+            value=torch.cat([values[:,:self.channels],self.offdiagonal_enabled*values[:,self.channels:]],-1)
+            return self.encoder(value.float())
+    def forward(self,native):return self.encode_statistics(self.statistics(native))
+
+class WaveCoactivationHead(nn.Module):
+    def __init__(self,prior,classes,width=128):
+        super().__init__();self.prior=prior;self.width=width;self.projection=nn.Linear(width,classes)
+        nn.init.zeros_(self.projection.weight);nn.init.zeros_(self.projection.bias)
+        self.register_buffer('output_scale',torch.ones(()));self.register_buffer('correction_gain',torch.ones(()))
+    def forward(self,values):
+        prior=self.prior(values[:,:-self.width])
+        with torch.autocast(values.device.type,enabled=False):delta=self.correction_gain*self.output_scale*self.projection(values[:,-self.width:].float())
+        return prior+delta.to(prior.dtype)
+
+class OrdinalFeatureHead(nn.Module):
+    """Private strength of one common ordinal-dynamics feature correction."""
+    def __init__(self,prior):
+        super().__init__();self.prior=prior;self.ordinal_gain=nn.Parameter(torch.ones(()))
+    def forward(self,values):
+        previous=values[:,:-256];native=previous[:,:-640]
+        adjusted=torch.cat([native[:,:-512],native[:,-512:-384]+self.ordinal_gain*values[:,-256:-128],native[:,-384:-128],native[:,-128:]+self.ordinal_gain*values[:,-128:],previous[:,-640:]],-1)
+        return self.prior(adjusted)
+
+class PhaseReadoutHead(nn.Module):
+    """Private class evidence from the common complex-coherence encoder."""
+    def __init__(self,prior,classes,width=128):
+        super().__init__();self.prior=prior;self.width=width;self.projection=nn.Linear(width,classes)
+        nn.init.zeros_(self.projection.weight);nn.init.zeros_(self.projection.bias)
+        self.register_buffer('output_scale',torch.ones(()));self.register_buffer('correction_gain',torch.ones(()))
+    def forward(self,values):
+        prior=self.prior(values[:,:-self.width])
+        with torch.autocast(values.device.type,enabled=False):delta=(self.correction_gain*self.output_scale)*self.projection(values[:,-self.width:].float())
+        return prior+delta.to(prior.dtype)
+
+class SplitLayerNorm(nn.Module):
+    """Two LayerNorm groups; surrounding dense matrices train across both groups."""
+    def __init__(self,width):
+        super().__init__();assert width%2==0;self.width=width
+        self.weight=nn.Parameter(torch.ones(width));self.bias=nn.Parameter(torch.zeros(width))
+    def forward(self,x):
+        n=self.width//2
+        return torch.cat([nn.functional.layer_norm(x[:,:n],(n,),self.weight[:n],self.bias[:n],1e-5),nn.functional.layer_norm(x[:,n:],(n,),self.weight[n:],self.bias[n:],1e-5)],-1)
+
+class CouplingReadoutHead(nn.Module):
+    """Private class evidence from the common cross-frequency coupling encoder."""
+    def __init__(self,prior,classes,width=128):
+        super().__init__();self.prior=prior;self.width=width;self.projection=nn.Linear(width,classes)
+        nn.init.zeros_(self.projection.weight);nn.init.zeros_(self.projection.bias)
+        self.register_buffer('output_scale',torch.ones(()));self.register_buffer('correction_gain',torch.ones(()))
+    def forward(self,values):
+        prior=self.prior(values[:,:-self.width])
+        with torch.autocast(values.device.type,enabled=False):delta=(self.correction_gain*self.output_scale)*self.projection(values[:,-self.width:].float())
+        return prior+delta.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,tangent_readout=True,shared_context_correction=True,wave_coactivation=True,ordinal_context=True,phase_coherence=True,cross_frequency=True,cbramod_feature_transfer=True,student_architecture=None,student_extension=True,post_embedding_extension=True,extension_activation='gelu',center_context_extension=True,context_crop='center',short_context_extension=True,short_crop='center',dual_context_extension=True,dual_crop='clinical-dual',geometry_extension=True,geometry_mode='mi-log',emotion_extension=True,emotion_mode='faced-log',emotion_activation='gelu',refinement_extension=True,refinement_mode='faced-log',refinement_activation='gelu',spatial_extension=True,spatial_mode='local',spatial_activation='gelu',spatial_motor_channels=None,conditional_extension=True,conditional_mode='partial',conditional_width=128):
+        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.backbone.student_encoder=CBraModFeatures(**(student_architecture or {}))
+        self.backbone.register_buffer('student_ordered_enabled',torch.ones(()))
+        self.backbone.student_readout=nn.Sequential(nn.Linear(self.backbone.student_encoder.output_dim,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        for t,(c,s,k) in SPECS.items():
+            self.adapters[t].student_input=FrequencyAdapter(c,32)
+            self.adapters[t].student_normalizer=Standardize(self.backbone.student_encoder.output_dim)
+        self.backbone.wave_coactivation=WaveCoactivationContext(2*wave_filters,width)
+        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()})
+        self.heads=nn.ModuleDict({t:TangentFeatureHead(head) for t,head in self.heads.items()})
+        self.heads=nn.ModuleDict({t:CodeBrainFeatureHead(head) for t,head in self.heads.items()})
+        self.heads=nn.ModuleDict({t:WaveCoactivationHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        self.heads=nn.ModuleDict({t:OrdinalFeatureHead(head) for t,head in self.heads.items()})
+        self.heads=nn.ModuleDict({t:PhaseReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert student_extension and post_embedding_extension
+        assert extension_activation in ('gelu','identity')
+        self.backbone.student_extension=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU() if extension_activation=='gelu' else nn.Identity(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert center_context_extension and context_crop in ('center','first')
+        self.context_crop=context_crop
+        for t,(c,s,k) in SPECS.items():
+            self.adapters[t].center_normalizer=Standardize(feature_dim(c)+30*c)
+            self.adapters[t].center_projection=nn.Linear(feature_dim(c)+30*c,width)
+        self.backbone.center_encoder=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert short_context_extension and short_crop in ('center','first')
+        self.short_crop=short_crop
+        for t,(c,s,k) in SPECS.items():
+            self.adapters[t].short_normalizer=Standardize(feature_dim(c)+30*c)
+            self.adapters[t].short_projection=nn.Linear(feature_dim(c)+30*c,width)
+        self.backbone.short_encoder=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert dual_context_extension and dual_crop in ('clinical-dual','clinical-duplicate')
+        self.dual_crop=dual_crop
+        for t,(c,s,k) in SPECS.items():
+            self.adapters[t].dual_normalizer=Standardize((feature_dim(c)+30*c)*(2 if t=='tuev' else 1))
+            self.adapters[t].dual_projection=nn.Linear((feature_dim(c)+30*c)*(2 if t=='tuev' else 1),width)
+        self.backbone.dual_encoder=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert geometry_extension and geometry_mode in ('mi-log','mi-linear')
+        self.geometry_mode=geometry_mode
+        for t,(c,s,k) in SPECS.items():
+            dimension=7*c*(c+1)//2 if t=='openbmi' else feature_dim(c)+30*c
+            self.adapters[t].geometry_normalizer=Standardize(dimension)
+            self.adapters[t].geometry_projection=nn.Linear(dimension,width)
+        self.backbone.geometry_encoder=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert emotion_extension and emotion_mode in ('faced-log','faced-linear')
+        self.emotion_mode=emotion_mode
+        for t,(c,s,k) in SPECS.items():
+            dimension=7*c*(c+1)//2 if t=='faced' else feature_dim(c)+30*c
+            self.adapters[t].emotion_normalizer=Standardize(dimension)
+            self.adapters[t].emotion_projection=nn.Linear(dimension,width)
+        assert emotion_activation in ('gelu','identity')
+        self.backbone.emotion_encoder=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU() if emotion_activation=='gelu' else nn.Identity(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert refinement_extension and refinement_mode in ('faced-log','faced-linear')
+        self.refinement_mode=refinement_mode
+        for t,(c,s,k) in SPECS.items():
+            dimension=7*c*(c+1)//2 if t=='faced' else feature_dim(c)+30*c
+            self.adapters[t].refinement_normalizer=Standardize(dimension)
+            self.adapters[t].refinement_projection=nn.Linear(dimension,width)
+        assert refinement_activation in ('gelu','identity')
+        self.backbone.refinement_encoder=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU() if refinement_activation=='gelu' else nn.Identity(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert spatial_extension and spatial_mode in ('local','native') and spatial_activation=='gelu'
+        self.spatial_mode=spatial_mode
+        self.spatial_motor_channels=tuple(spatial_motor_channels or MOTOR_CHANNELS)
+        assert len(self.spatial_motor_channels)==62
+        for t,(c,s,k) in SPECS.items():
+            dimension=981 if t=='openbmi' else (7*c*(c+1)//2 if t=='faced' else feature_dim(c)+30*c)
+            self.adapters[t].spatial_normalizer=Standardize(dimension)
+            self.adapters[t].spatial_projection=nn.Linear(dimension,width)
+        self.backbone.spatial_encoder=nn.Sequential(nn.Linear(width,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,width),nn.LayerNorm(width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],width) for t,head in self.heads.items()})
+        assert conditional_extension and conditional_mode in ('partial','marginal')
+        assert conditional_width in (128,256)
+        self.conditional_mode=conditional_mode
+        for t,(c,s,k) in SPECS.items():
+            dimension=952 if t=='tuev' else self.adapters[t].spatial_projection.in_features
+            self.adapters[t].conditional_normalizer=Standardize(dimension)
+            self.adapters[t].conditional_projection=nn.Linear(dimension,conditional_width)
+        norm=SplitLayerNorm if conditional_width==256 else nn.LayerNorm
+        self.backbone.conditional_encoder=nn.Sequential(nn.Linear(conditional_width,2*conditional_width),norm(2*conditional_width),nn.GELU(),nn.Dropout(.3),nn.Linear(2*conditional_width,conditional_width),norm(conditional_width))
+        self.heads=nn.ModuleDict({t:CouplingReadoutHead(head,SPECS[t][2],conditional_width) for t,head in self.heads.items()})
+    def conditional_features(self,t,x):
+        if t!='tuev':return self.spatial_features(t,x)
+        from partial_covariance_features import partial_covariance_features
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(x.device.type,enabled=False):return partial_covariance_features(t,x,self.conditional_mode=='partial')
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def conditional_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            return self.backbone.conditional_encoder(self.adapters[t].conditional_projection(self.adapters[t].conditional_normalizer(values.float())))
+    def spatial_features(self,t,x):
+        if t!='openbmi':return self.refinement_features(t,x)
+        from local_channel_features import local_channel_signals
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(x.device.type,enabled=False):
+                signals=local_channel_signals(x,self.spatial_motor_channels,self.spatial_mode=='local')
+                return torch.cat([extract_features('tuev',signals),coupling_features('tuev',signals)],-1)
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def spatial_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].spatial_normalizer(values.float())
+            return self.backbone.spatial_encoder(self.adapters[t].spatial_projection(normalized))
+    def refinement_features(self,t,x):
+        from native_log_covariance_features import connectivity
+        from short_context_features import short_spectral_features
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(x.device.type,enabled=False):
+                if t=='faced':return connectivity(t,x,logarithmic=self.refinement_mode=='faced-log')
+                view=x.flatten(2)[...,:200]
+                return torch.cat([short_spectral_features(t,view),coupling_features(t,view)],-1)
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def refinement_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].refinement_normalizer(values.float())
+            return self.backbone.refinement_encoder(self.adapters[t].refinement_projection(normalized))
+    def emotion_features(self,t,x):
+        from native_log_covariance_features import connectivity
+        from short_context_features import short_spectral_features
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(x.device.type,enabled=False):
+                if t=='faced':return connectivity(t,x,logarithmic=self.emotion_mode=='faced-log')
+                view=x.flatten(2)[...,:200]
+                return torch.cat([short_spectral_features(t,view),coupling_features(t,view)],-1)
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def emotion_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].emotion_normalizer(values.float())
+            return self.backbone.emotion_encoder(self.adapters[t].emotion_projection(normalized))
+    def geometry_features(self,t,x):
+        from native_log_covariance_features import connectivity
+        from short_context_features import short_spectral_features
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(x.device.type,enabled=False):
+                if t=='openbmi':return connectivity(t,x,logarithmic=self.geometry_mode=='mi-log')
+                view=x.flatten(2)[...,:200]
+                return torch.cat([short_spectral_features(t,view),coupling_features(t,view)],-1)
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def geometry_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].geometry_normalizer(values.float())
+            return self.backbone.geometry_encoder(self.adapters[t].geometry_projection(normalized))
+    def dual_features(self,t,x):
+        from short_context_features import short_spectral_features
+        raw=x.flatten(2);first=raw[...,:200];views=[first]
+        if t=='tuev':
+            start=(raw.shape[-1]-200)//2
+            views.append(raw[...,start:start+200] if self.dual_crop=='clinical-dual' else first)
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(raw.device.type,enabled=False):return torch.cat([torch.cat([short_spectral_features(t,v),coupling_features(t,v)],-1) for v in views],-1)
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def dual_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].dual_normalizer(values.float())
+            return self.backbone.dual_encoder(self.adapters[t].dual_projection(normalized))
+    def short_features(self,t,x):
+        from short_context_features import short_spectral_features
+        raw=x.flatten(2);start=(raw.shape[-1]-200)//2 if self.short_crop=='center' else 0
+        cropped=raw[...,start:start+200];assert cropped.shape[-1]==200
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(raw.device.type,enabled=False):return torch.cat([short_spectral_features(t,cropped),coupling_features(t,cropped)],-1)
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def short_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].short_normalizer(values.float())
+            return self.backbone.short_encoder(self.adapters[t].short_projection(normalized))
+    def center_features(self,t,x):
+        raw=x.flatten(2);start=(raw.shape[-1]-400)//2 if self.context_crop=='center' else 0
+        cropped=raw[...,start:start+400];assert cropped.shape[-1]==400
+        old=torch.backends.cuda.matmul.allow_tf32;torch.backends.cuda.matmul.allow_tf32=False
+        try:
+            with torch.autocast(raw.device.type,enabled=False):return torch.cat([extract_features(t,cropped),coupling_features(t,cropped)],-1)
+        finally:torch.backends.cuda.matmul.allow_tf32=old
+    def center_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].center_normalizer(values.float())
+            return self.backbone.center_encoder(self.adapters[t].center_projection(normalized))
+    def student_extension_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            assert values.shape[-1]==128
+            return self.backbone.student_extension(values.float())
+
+    def student_features(self,t,x):
+        outputs=[];old_fastpath=torch.backends.mha.get_fastpath_enabled();torch.backends.mha.set_fastpath_enabled(False)
+        try:
+            for raw in x.split(16):
+                signal=torch.nan_to_num(raw.float().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5)
+                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)
+                with torch.autocast(signal.device.type,dtype=torch.bfloat16,enabled=signal.device.type=='cuda'):
+                    outputs.append(self.backbone.student_encoder(self.adapters[t].student_input(signal)))
+        finally:torch.backends.mha.set_fastpath_enabled(old_fastpath)
+        return torch.cat(outputs).float()
+    def student_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].student_normalizer(values.float())
+            normalized=torch.cat([normalized[:,:256],self.backbone.student_ordered_enabled*normalized[:,256:]],-1)
+            return self.backbone.student_readout(normalized)
+    def coupling_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):return self.backbone.coupling_encoder(self.adapters[t].coupling_embedding(values.float()))
+    def phase_embedding(self,t,values):
+        with torch.autocast(values.device.type,enabled=False):
+            normalized=self.adapters[t].phase_normalizer(values.float())
+            normalized=torch.cat([normalized[:,:PHASE_HALF],self.backbone.phase_imaginary_enabled*normalized[:,PHASE_HALF:]],-1)
+            return self.backbone.phase_encoder(normalized)
+    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)
+        if covariances is None:covariances=extract_covariances(t,x)
+        tangent=extract_tangent_features(covariances,self.adapters[t].spatial_weight)
+        representation,fusion_delta,covariance_delta,fusion_input=self.backbone(*adapted,tangent_features=tangent)
+        if t in ('faced','openbmi'):
+            representation=torch.cat([representation[:,:-384],torch.zeros_like(representation[:,-384:-128]),representation[:,-128:]],-1)
+        tokens=torch.zeros(len(signal),signal.shape[-1]//200,24*64,device=signal.device,dtype=torch.bfloat16)
+        code_fusion,code_covariance=self.backbone.codebrain_correction(tokens,representation,fusion_input)
+        coactivation=self.backbone.wave_coactivation(representation)
+        with torch.autocast(signal.device.type,enabled=False):
+            ordinal=self.adapters[t].ordinal_embedding(ordinal_features(t,x))
+            ordinal_covariance=self.backbone.ordinal_context(ordinal.float())
+        added=.001*nn.functional.linear(ordinal_covariance,self.backbone.covariance_projection.weight,None)
+        ordinal_fusion=self.backbone.fusion(fusion_input+added.to(fusion_input.dtype))-representation[:,-512:-384]
+        phase=self.phase_embedding(t,phase_features(t,x,self.adapters[t].spatial_weight))
+        coupling=self.coupling_embedding(t,coupling_features(t,x))
+        student_values=self.student_features(t,x)
+        student=self.student_embedding(t,student_values)
+        extension=self.student_extension_embedding(t,student)
+        return self.heads[t](torch.cat([representation,fusion_delta,covariance_delta,code_fusion,code_covariance,coactivation,ordinal_fusion,ordinal_covariance,phase,coupling,student,extension,self.center_embedding(t,self.center_features(t,x)),self.short_embedding(t,self.short_features(t,x)),self.dual_embedding(t,self.dual_features(t,x)),self.geometry_embedding(t,self.geometry_features(t,x)),self.emotion_embedding(t,self.emotion_features(t,x)),self.refinement_embedding(t,self.refinement_features(t,x)),self.spatial_embedding(t,self.spatial_features(t,x)),self.conditional_embedding(t,self.conditional_features(t,x))],-1))
+
+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/finalization/submission/local_channel_features.py

@@ -0,0 +1,26 @@
+"""Named local channel differences. These are fixed differences, not a physical CSD model."""
+import torch
+ALIASES={'T3':'T7','T4':'T8','T5':'P7','T6':'P8'}
+NEIGHBORS={'C3':('F3','CZ','P3','T7'),'CZ':('FZ','C3','C4','PZ'),'C4':('F4','CZ','P4','T8'),'P3':('C3','PZ','O1','P7'),'PZ':('CZ','P3','P4','O1','O2'),'P4':('C4','PZ','O2','P8')}
+def canonical(channels):
+    result=[ALIASES.get(name.upper(),name.upper()) for name in channels]
+    assert len(set(result))==len(result)
+    return result
+
+def projection_matrix(channels,local=True):
+    names=canonical(channels);matrix=torch.zeros(len(NEIGHBORS),len(names))
+    for i,(center,neighbors) in enumerate(NEIGHBORS.items()):
+        matrix[i,names.index(center)]=1
+        if local:
+            for name in neighbors:matrix[i,names.index(name)]-=1/len(neighbors)
+        else:matrix[i]-=1/len(names)
+    return matrix
+
+@torch.no_grad()
+def local_channel_signals(signal,channels,local=True):
+    with torch.autocast(signal.device.type,enabled=False):
+        x=torch.nan_to_num(signal.float().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5)
+        names=canonical(channels)
+        if local:
+            return torch.stack([(x[:,names.index(center),None]-x[:,[names.index(n) for n in neighbors]]).mean(1) for center,neighbors in NEIGHBORS.items()],1)
+        return x[:,[names.index(center) for center in NEIGHBORS]]-x.mean(1,keepdim=True)

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

@@ -0,0 +1,41 @@
+"""Portable fixed common activation normalization groups over a frozen, hash-bound complete parent."""
+from shared_activation_groups_parent_model import *
+from activation_groups_math import MODES, configure_groups
+from temporal_convolution_math import SharedTemporalConvolution, raw_convolution_features, precise_convolution
+
+SourceHybridModel = HybridModel
+
+
+class ActivationGroupsHead(nn.Module):
+    def __init__(self, classes):
+        super().__init__()
+        self.projection = nn.Linear(128, classes)
+        nn.init.normal_(self.projection.weight, std=.02)
+        nn.init.zeros_(self.projection.bias)
+        self.register_buffer('blend_strength', torch.tensor(0.))
+
+
+class HybridModel(SourceHybridModel):
+    def __init__(self, activation_groups_refinement=False, activation_groups_mode='all', **kwargs):
+        super().__init__(**kwargs)
+        assert activation_groups_refinement and activation_groups_mode in MODES
+        self.activation_groups_mode = activation_groups_mode
+        for track in TRACKS:
+            self.adapters[track].activation_groups_projection = nn.Linear(SPECS[track][0], 16, bias=False)
+        self.backbone.activation_groups_encoder = configure_groups(SharedTemporalConvolution(), activation_groups_mode)
+        self.activation_groups_heads = nn.ModuleDict({track: ActivationGroupsHead(SPECS[track][2]) for track in TRACKS})
+
+    def activation_groups_logits(self, track, values):
+        with precise_convolution(values.device.type):
+            adapted = self.adapters[track].activation_groups_projection(values.float().transpose(1, 2)).transpose(1, 2)
+            embedding = self.backbone.activation_groups_encoder(adapted)
+            return self.activation_groups_heads[track].projection(embedding)
+
+    def activation_groups_predict(self, track, values, prior, strength=None):
+        logits = self.activation_groups_logits(track, values)
+        strength = self.activation_groups_heads[track].blend_strength if strength is None else strength
+        return (1-strength)*prior.float()+strength*logits
+
+    def forward(self, track, raw, features=None, covariances=None, covariance_features=None):
+        prior = super().forward(track, raw, features, covariances=covariances, covariance_features=covariance_features)
+        return self.activation_groups_predict(track, raw_convolution_features(track, raw, 'raw'), prior)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/multitaper_covariance_features.py

@@ -0,0 +1,28 @@
+"""Fixed DPSS covariance geometry; no fitted reference or adaptive spectral weights."""
+from functools import lru_cache
+import numpy as np,torch
+from scipy.signal.windows import dpss
+from native_log_covariance_features import BANDS
+from partial_covariance_features import summarize_matrix
+@lru_cache(maxsize=8)
+def tapers(n):
+ v=np.array(dpss(n,3.,Kmax=5,sym=True,norm=2),dtype=np.float64,copy=True);v*=np.sqrt(n)/np.linalg.norm(v,axis=1,keepdims=True);return v
+@torch.no_grad()
+def tapered_matrices(track,raw):
+ x=torch.nan_to_num(raw.double().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5);x=x-x[...,:1];x=x-x.mean(-1,keepdim=True)
+ if track in ['ad65','openbmi','longitudinal']:x=x-x.mean(1,keepdim=True)
+ b,c,n=x.shape;reference=x.square().mean((-1,-2))[:,None,None];window=torch.tensor(np.concatenate([tapers(n),np.ones((1,n))]),device=x.device);z=torch.fft.rfft(x[None]*window[:,None,None,:],dim=-1);freq=torch.fft.rfftfreq(n,1/200,device=x.device,dtype=torch.float64);eye=torch.eye(c,device=x.device,dtype=torch.float64);parts={k:[] for k in ['multitaper','single','rectangle']}
+ for lo,hi in BANDS:
+  v=torch.fft.irfft(z*((freq>=lo)&(freq<hi)),n=n,dim=-1);cov=v@v.transpose(-1,-2)/n
+  for key,value in [('multitaper',cov[:5].mean(0)),('single',cov[0]),('rectangle',cov[5])]:
+   power=value.diagonal(dim1=-2,dim2=-1).mean(-1)[:,None,None];normal=torch.where(power>(1e-10*reference).clamp_min(1e-20),value/power.clamp_min(1e-20),eye);matrix=.95*normal+.05*eye;parts[key].append((matrix+matrix.transpose(-1,-2))*.5)
+ return {k:torch.stack(v,1) for k,v in parts.items()}
+@torch.no_grad()
+def multitaper_covariance(track,raw):
+ matrices=tapered_matrices(track,raw);result={}
+ for key,matrix in matrices.items():
+  if track=='tuev':value=summarize_matrix(matrix,True)
+  else:
+   c=matrix.shape[-1];nonidentity=(matrix-torch.eye(c,device=matrix.device)).abs().amax((-1,-2))>0;values,vectors=torch.linalg.eigh(matrix);log=(vectors*values.clamp_min(1e-6).log().unsqueeze(-2))@vectors.transpose(-1,-2);log=torch.where(nonidentity[...,None,None],log,0.);i,j=torch.triu_indices(c,c,device=matrix.device);scale=torch.ones(i.shape,device=matrix.device,dtype=torch.float64);scale[i!=j]=2.**.5;value=(log[...,i,j]*scale).flatten(1).float()
+  assert torch.isfinite(value).all();result[key]=value
+ return result

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/native_log_covariance_features.py

@@ -0,0 +1,35 @@
+"""Native-channel trace-normalized covariance geometry, with a matched linear control."""
+import torch
+BANDS=((1,4),(4,8),(8,12),(12,16),(16,20),(20,28),(28,40))
+
+@torch.no_grad()
+def band_matrices(track,x):
+    x=torch.nan_to_num(x.float().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5)
+    x=x-x[...,:1];x=x-x.mean(-1,keepdim=True)
+    if track in ('ad65','openbmi','longitudinal'):x=x-x.mean(1,keepdim=True)
+    reference=x.square().mean((-1,-2),keepdim=True)
+    n=x.shape[-1];c=x.shape[1];z=torch.fft.rfft(x,dim=-1);f=torch.fft.rfftfreq(n,1/200,device=x.device);eye=torch.eye(c,device=x.device);parts=[]
+    for low,high in BANDS:
+        v=torch.fft.irfft(z*((f>=low)&(f<high)),n=n,dim=-1)
+        covariance=(v@v.transpose(-1,-2))/n
+        power=covariance.diagonal(dim1=-2,dim2=-1).mean(-1)[:,None,None]
+        active=power>(1e-10*reference).clamp_min(1e-20)
+        normalized=covariance/power.clamp_min(1e-20)
+        normalized=torch.where(active,normalized,eye)
+        matrix=.95*normalized+.05*eye
+        parts.append((matrix+matrix.transpose(-1,-2))*.5)
+    return torch.stack(parts,1)
+
+@torch.no_grad()
+def connectivity(track,x,logarithmic=True):
+    matrix=band_matrices(track,x);c=matrix.shape[-1]
+    if logarithmic:
+        # CUDA eigh can perturb exactly degenerate identity eigenvalues.
+        # Preserve the mathematical log(I)=0 for exactly silent/isotropic bands.
+        nonidentity=(matrix-torch.eye(c,device=matrix.device)).abs().amax((-1,-2))>0
+        values,vectors=torch.linalg.eigh(matrix)
+        matrix=(vectors*values.clamp_min(1e-6).log().unsqueeze(-2))@vectors.transpose(-1,-2)
+        matrix=torch.where(nonidentity[...,None,None],matrix,torch.zeros_like(matrix))
+    else:matrix=matrix-torch.eye(c,device=matrix.device)
+    i,j=torch.triu_indices(c,c,device=matrix.device);scale=torch.where(i==j,1.,2.**.5)
+    return (matrix[...,i,j]*scale).flatten(1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/partial_covariance_features.py

@@ -0,0 +1,33 @@
+"""Native regularized partial and marginal covariance statistics; no causal claims."""
+import torch
+from native_log_covariance_features import BANDS
+
+@torch.no_grad()
+def summarize_matrix(matrix,partial=True):
+    c=matrix.shape[-1];value=matrix.double()
+    if partial:value=torch.linalg.inv(value)
+    diagonal=value.diagonal(dim1=-2,dim2=-1).clamp_min(1e-12)
+    correlation=value/(diagonal[...,None]*diagonal[...,None,:]).sqrt()
+    if partial:correlation=-correlation
+    ii,jj=torch.triu_indices(c,c,offset=1,device=matrix.device)
+    variance=(-1. if partial else 1.)*diagonal.log()
+    pairs=torch.atanh(correlation[...,ii,jj].clamp(-.999,.999))
+    return torch.cat([variance,pairs],-1).flatten(1).float()
+
+
+@torch.no_grad()
+def stable_band_matrices(track,x):
+    x=torch.nan_to_num(x.double().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5)
+    x=x-x[...,:1];x=x-x.mean(-1,keepdim=True)
+    if track in ('ad65','openbmi','longitudinal'):x=x-x.mean(1,keepdim=True)
+    reference=x.square().mean((-1,-2),keepdim=True);n=x.shape[-1];c=x.shape[1]
+    z=torch.fft.rfft(x,dim=-1);f=torch.fft.rfftfreq(n,1/200,device=x.device,dtype=torch.float64);eye=torch.eye(c,device=x.device,dtype=torch.float64);parts=[]
+    for lo,hi in BANDS:
+        v=torch.fft.irfft(z*((f>=lo)&(f<hi)),n=n,dim=-1);cov=v@v.transpose(-1,-2)/n;power=cov.diagonal(dim1=-2,dim2=-1).mean(-1)[:,None,None]
+        normalized=torch.where(power>(1e-10*reference).clamp_min(1e-20),cov/power.clamp_min(1e-20),eye);matrix=.95*normalized+.05*eye;parts.append((matrix+matrix.transpose(-1,-2))*.5)
+    return torch.stack(parts,1)
+
+@torch.no_grad()
+def partial_covariance_features(track,x,partial=True):
+    with torch.autocast(x.device.type,enabled=False):
+        return summarize_matrix(stable_band_matrices(track,x),partial)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/phase_features.py

@@ -0,0 +1,37 @@
+"""Complex spectral coherence of the existing 24 spatial filters in ten bands."""
+import torch
+from covariances import BANDS
+CHANNELS=24
+PHASE_HALF=len(BANDS)*CHANNELS*(CHANNELS-1)//2
+PHASE_DIM=2*PHASE_HALF
+
+@torch.no_grad()
+def phase_features(track,x,spatial_weight):
+    previous_tf32=torch.backends.cuda.matmul.allow_tf32
+    try:
+        torch.backends.cuda.matmul.allow_tf32=False
+        with torch.autocast(x.device.type,enabled=False):
+            x=torch.nan_to_num(x.float().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5)
+            x=x-x.mean(-1,keepdim=True)
+            if track in ('faced','tuev'):x=x/x.square().mean(-1,keepdim=True).clamp_min(1e-12).sqrt()
+            else:x=x-x.mean(1,keepdim=True)
+            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
+            w=spatial_weight.float()/spatial_weight.float().norm(dim=-1,keepdim=True).clamp_min(1e-6)
+            index=torch.triu_indices(CHANNELS,CHANNELS,1,device=x.device)
+            real_parts=[];imaginary_parts=[]
+            for band,(lo,hi) in enumerate(BANDS):
+                v=z[...,2*lo:2*hi].flatten(2)
+                vr=w[band][None]@v.real;vi=w[band][None]@v.imag
+                real=(vr@vr.transpose(-1,-2)+vi@vi.transpose(-1,-2))/v.shape[-1]
+                imaginary=(vi@vr.transpose(-1,-2)-vr@vi.transpose(-1,-2))/v.shape[-1]
+                # Signals have unit global RMS; this floor suppresses phase of numerical silence.
+                power=real.diagonal(dim1=-2,dim2=-1).clamp_min(1e-6)
+                denominator=(power[:,:,None]*power[:,None,:]).sqrt().clamp_min(1e-12)
+                real=(real/denominator).clamp(-.999,.999)
+                imaginary=(imaginary/denominator).clamp(-.999,.999)
+                real_parts.append(torch.atanh(real[:,index[0],index[1]]))
+                imaginary_parts.append(torch.atanh(imaginary[:,index[0],index[1]]))
+            return torch.cat(real_parts+imaginary_parts,-1)
+    finally:torch.backends.cuda.matmul.allow_tf32=previous_tf32

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/shared_activation_groups_parent_model.py

@@ -0,0 +1,52 @@
+"""Portable temporal-scale bank integration over the complete frozen490 source."""
+from shared_temporal_basis_model import *
+from torch.nn import functional as F
+from temporal_scale_math import temporal_scale_bank, MODES
+from temporal_convolution_math import SharedTemporalConvolution, raw_convolution_features, precise_convolution
+
+SourceHybridModel = HybridModel
+
+
+class TemporalScaleHead(nn.Module):
+    def __init__(self, classes):
+        super().__init__()
+        self.projection = nn.Linear(128, classes)
+        nn.init.normal_(self.projection.weight, std=.02)
+        nn.init.zeros_(self.projection.bias)
+        self.register_buffer('blend_strength', torch.tensor(0.))
+
+
+class HybridModel(SourceHybridModel):
+    def __init__(self, temporal_scale_refinement=False, temporal_scale_mode='diverse', **kwargs):
+        super().__init__(**kwargs)
+        assert temporal_scale_refinement and temporal_scale_mode in MODES
+        self.temporal_scale_mode = temporal_scale_mode
+        for track in TRACKS:
+            self.adapters[track].temporal_scale_projection = nn.Linear(SPECS[track][0],16,bias=False)
+        self.backbone.temporal_scale_encoder = SharedTemporalConvolution()
+        self.backbone.temporal_scale_encoder.temporal = nn.Conv2d(1,16,(1,17),stride=(1,2),padding=(0,8),bias=False)
+        self.temporal_scale_heads = nn.ModuleDict({track:TemporalScaleHead(SPECS[track][2]) for track in TRACKS})
+
+    def temporal_scale_logits(self, track, values):
+        with precise_convolution(values.device.type):
+            block = self.backbone.temporal_scale_encoder
+            x = self.adapters[track].temporal_scale_projection(values.float().transpose(1,2)).transpose(1,2).unsqueeze(1)
+            x = temporal_scale_bank(x,block.temporal.weight,self.temporal_scale_mode)
+            x = block.norm_temporal(x)
+            x = block.dropout_spatial(F.avg_pool2d(F.elu(block.norm_spatial(block.spatial(x))),(1,4)))
+            x = block.dropout_separable(F.avg_pool2d(F.elu(block.norm_separable(block.pointwise(block.depthwise(x)))),(1,8)))
+            x = x.squeeze(2)
+            mean = x.mean(-1)
+            std = ((x-mean[...,None]).square().mean(-1)+1e-6).sqrt()
+            x = block.dropout_embedding(block.norm_embedding(F.gelu(block.embedding(torch.cat([mean,std],-1)))))
+            return self.temporal_scale_heads[track].projection(x)
+
+    def temporal_scale_predict(self, track, values, prior, strength=None):
+        logits = self.temporal_scale_logits(track,values)
+        strength = self.temporal_scale_heads[track].blend_strength if strength is None else strength
+        return (1-strength)*prior.float()+strength*logits
+
+    def forward(self, track, raw, features=None, covariances=None, covariance_features=None):
+        prior = super().forward(track,raw,features,covariances=covariances,covariance_features=covariance_features)
+        values = raw_convolution_features(track,raw,'raw')
+        return self.temporal_scale_predict(track,values,prior)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/shared_expert_routing_math.py

@@ -0,0 +1,14 @@
+"""443 bounded two-expert routing; no data or fitted state."""
+import torch
+
+
+def bounded_expert_weights(router_logits,task_bias,mode):
+    if mode=='input':scores=router_logits+task_bias
+    elif mode=='task':scores=router_logits*0.+task_bias
+    elif mode=='uniform':scores=(router_logits+task_bias)*0.
+    else:raise ValueError(mode)
+    return (2*torch.tanh(scores)).softmax(-1)
+
+
+def mix_expert_outputs(first,second,weights):
+    return first+weights[...,1:2]*(second-first)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/shared_expert_routing_model.py

@@ -0,0 +1,45 @@
+"""443: one shared backbone with two shared feature experts and bounded routing."""
+from shared_spectral_filter_model import *
+from shared_expert_routing_math import bounded_expert_weights,mix_expert_outputs
+SourceHybridModel=HybridModel
+
+
+class ExpertRoutingReadout(nn.Module):
+    def __init__(self,classes,scale):
+        super().__init__();self.projection=nn.Linear(128,classes)
+        nn.init.zeros_(self.projection.weight);nn.init.zeros_(self.projection.bias)
+        self.register_buffer('output_scale',scale.detach().clone());self.register_buffer('correction_gain',torch.tensor(1.))
+
+
+class HybridModel(SourceHybridModel):
+    def __init__(self,expert_routing_refinement=False,expert_routing_mode='input',expert_routing_enabled=1.,**kwargs):
+        super().__init__(**kwargs);assert expert_routing_refinement and expert_routing_mode in ['input','task','uniform'];self.expert_routing_mode=expert_routing_mode
+        for track in TRACKS:
+            dimension=self.adapters[track].weighted_pattern_projection.in_features
+            self.adapters[track].expert_routing_projection=nn.Linear(dimension,128)
+            self.adapters[track].expert_task_logits=nn.Parameter(torch.zeros(2))
+        self.backbone.expert_blocks=nn.ModuleList([nn.Sequential(nn.Linear(128,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,128),nn.LayerNorm(128)) for _ in range(2)])
+        self.backbone.expert_router=nn.Linear(128,2,bias=False);nn.init.zeros_(self.backbone.expert_router.weight)
+        self.backbone.register_buffer('expert_routing_enabled',torch.tensor(float(expert_routing_enabled)))
+        self.expert_routing_heads=nn.ModuleDict({track:ExpertRoutingReadout(SPECS[track][2],self.heads[track].output_scale) for track in TRACKS})
+
+    def expert_routing_features(self,track,raw,features=None):
+        return self.weighted_pattern_features(track,raw,features=features)
+
+    def expert_routing_embedding(self,track,values,return_routing=False):
+        with torch.autocast(values.device.type,enabled=False):
+            adapter=self.adapters[track];z=adapter.expert_routing_projection(adapter.weighted_pattern_normalizer(values.float()))
+            first=self.backbone.expert_blocks[0](z);second=self.backbone.expert_blocks[1](z)
+            weights=bounded_expert_weights(self.backbone.expert_router(z),adapter.expert_task_logits,self.expert_routing_mode)
+            result=mix_expert_outputs(first,second,weights)
+        return (result,weights) if return_routing else result
+
+    def expert_routing_predict(self,track,values,prior,gain=None,return_standalone=False):
+        with torch.autocast(values.device.type,enabled=False):
+            head=self.expert_routing_heads[track];standalone=head.projection(self.expert_routing_embedding(track,values))*self.backbone.expert_routing_enabled
+            strength=head.correction_gain if gain is None else gain;result=prior.float()+(strength*head.output_scale)*standalone
+        return (result,standalone) if return_standalone else result
+
+    def forward(self,track,raw,features=None,covariances=None,covariance_features=None):
+        prior=super().forward(track,raw,features,covariances=covariances,covariance_features=covariance_features)
+        return self.expert_routing_predict(track,self.expert_routing_features(track,raw,features=features),prior)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/shared_spectral_features.py

@@ -0,0 +1,44 @@
+"""431 deterministic per-window log spectra and seven shared trainable filters."""
+import torch
+from torch import nn
+INITIAL_CENTERS=(2.5,6.,10.,14.,18.,24.,34.)
+INITIAL_WIDTHS=(1.5,2.,2.,2.,2.,4.,6.)
+
+
+@torch.no_grad()
+def _log_spectrum_batch(track,raw):
+    with torch.autocast(raw.device.type,enabled=False):
+        x=torch.nan_to_num(raw.double().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5);x=x-x[...,:1];x=x-x.mean(-1,keepdim=True)
+        if track in ('ad65','openbmi','longitudinal'):x=x-x.mean(1,keepdim=True)
+        window=torch.hann_window(400,periodic=True,device=x.device,dtype=torch.float64)
+        power=torch.fft.rfft(x.unfold(-1,400,200)*window,dim=-1).abs().square().mean(-2)[...,2:97]
+        relative=power/power.sum(-1,keepdim=True).clamp_min(1e-20);logarithm=relative.clamp_min(1e-12).log()
+        return (torch.round(logarithm*1e9)/1e9).float()
+
+
+@torch.no_grad()
+def log_relative_spectrum(track,raw):
+    outputs=[]
+    for chunk in raw.split(16) if len(raw) else [raw]:
+        count=len(chunk)
+        if count<16:chunk=torch.cat([chunk,raw.new_zeros((16-count,*raw.shape[1:]))])
+        outputs.append(_log_spectrum_batch(track,chunk)[:count])
+    return torch.cat(outputs)
+
+
+class SharedGaussianSpectralFilters(nn.Module):
+    def __init__(self):
+        super().__init__()
+        centers=(torch.tensor(INITIAL_CENTERS)-1)/47;widths=(torch.tensor(INITIAL_WIDTHS)-.5)/11.5
+        self.raw_centers=nn.Parameter(torch.logit(centers));self.raw_widths=nn.Parameter(torch.logit(widths))
+        self.register_buffer('frequencies',torch.arange(1.,48.5,.5))
+
+    def physical_parameters(self):
+        return 1+47*self.raw_centers.sigmoid(),.5+11.5*self.raw_widths.sigmoid()
+
+    def log_weights(self):
+        center,width=self.physical_parameters();z=-.5*((self.frequencies[None]-center[:,None])/width[:,None]).square()
+        return z.log_softmax(-1)
+
+    def forward(self,log_spectrum):
+        return torch.logsumexp(log_spectrum[:,:,None,:]+self.log_weights()[None,None],-1).flatten(1)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/shared_spectral_filter_model.py

@@ -0,0 +1,41 @@
+"""431: one shared learned spectral bank and jointly trained five-track residual."""
+from weighted_pattern_model import *
+from shared_spectral_features import SharedGaussianSpectralFilters,log_relative_spectrum
+SourceHybridModel=HybridModel
+
+
+class SpectralFilterReadout(nn.Module):
+    def __init__(self,classes,scale):
+        super().__init__();self.projection=nn.Linear(128,classes);nn.init.zeros_(self.projection.weight);nn.init.zeros_(self.projection.bias)
+        self.register_buffer('output_scale',scale.detach().clone());self.register_buffer('correction_gain',torch.tensor(1.))
+
+
+class HybridModel(SourceHybridModel):
+    def __init__(self,spectral_filter_refinement=False,spectral_filter_enabled=1.,**kwargs):
+        super().__init__(**kwargs);assert spectral_filter_refinement
+        self.backbone.spectral_filters=SharedGaussianSpectralFilters()
+        for track in TRACKS:
+            dimension=7*SPECS[track][0];self.adapters[track].spectral_filter_normalizer=Standardize(dimension);self.adapters[track].spectral_filter_projection=nn.Linear(dimension,128)
+        self.backbone.spectral_filter_encoder=nn.Sequential(nn.Linear(128,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,128),nn.LayerNorm(128))
+        self.backbone.register_buffer('spectral_filter_enabled',torch.tensor(float(spectral_filter_enabled)))
+        self.spectral_filter_heads=nn.ModuleDict({track:SpectralFilterReadout(SPECS[track][2],self.heads[track].output_scale) for track in TRACKS})
+
+    def spectral_filter_spectrum(self,track,raw):return log_relative_spectrum(track,raw)
+
+    def spectral_filter_features(self,spectrum):
+        with torch.autocast(spectrum.device.type,enabled=False):return self.backbone.spectral_filters(spectrum.float())
+
+    def spectral_filter_embedding(self,track,spectrum):
+        with torch.autocast(spectrum.device.type,enabled=False):
+            features=self.spectral_filter_features(spectrum);adapter=self.adapters[track]
+            return self.backbone.spectral_filter_encoder(adapter.spectral_filter_projection(adapter.spectral_filter_normalizer(features)))
+
+    def spectral_filter_predict(self,track,spectrum,prior,gain=None,return_standalone=False):
+        with torch.autocast(spectrum.device.type,enabled=False):
+            head=self.spectral_filter_heads[track];standalone=head.projection(self.spectral_filter_embedding(track,spectrum))*self.backbone.spectral_filter_enabled
+            strength=head.correction_gain if gain is None else gain;result=prior.float()+(strength*head.output_scale)*standalone
+        return (result,standalone) if return_standalone else result
+
+    def forward(self,track,raw,features=None,covariances=None,covariance_features=None):
+        prior=super().forward(track,raw,features,covariances=covariances,covariance_features=covariance_features)
+        return self.spectral_filter_predict(track,self.spectral_filter_spectrum(track,raw),prior)

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

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

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/temporal_convolution_math.py

@@ -0,0 +1,79 @@
+"""469 deterministic per-window preprocessing and shared temporal convolution."""
+import contextlib, functools, math
+import torch
+from torch import nn
+from torch.nn import functional as F
+MODES=('raw','phase','permuted')
+
+@contextlib.contextmanager
+def precise_convolution(device_type):
+    old=(torch.backends.cuda.matmul.allow_tf32,torch.backends.cudnn.allow_tf32,torch.backends.cudnn.benchmark,torch.backends.cudnn.deterministic)
+    torch.backends.cuda.matmul.allow_tf32=False
+    torch.backends.cudnn.allow_tf32=False
+    torch.backends.cudnn.benchmark=False
+    torch.backends.cudnn.deterministic=True
+    try:
+        with torch.autocast(device_type,enabled=False):yield
+    finally:
+        torch.backends.cuda.matmul.allow_tf32,torch.backends.cudnn.allow_tf32,torch.backends.cudnn.benchmark,torch.backends.cudnn.deterministic=old
+
+@functools.lru_cache(maxsize=4)
+def phase_angles(length):
+    g=torch.Generator(device='cpu').manual_seed(469000+length)
+    p=(torch.rand(length//2+1,dtype=torch.float64,generator=g)*2-1)*math.pi
+    p[0]=0.
+    if length%2==0:p[-1]=0.
+    return p
+
+@functools.lru_cache(maxsize=4)
+def time_permutation(length):
+    return torch.randperm(length,generator=torch.Generator(device='cpu').manual_seed(469100+length))
+
+def transform_preprocessed(x,mode):
+    assert mode in MODES
+    if mode=='raw':return x
+    if mode=='permuted':return x[...,time_permutation(x.shape[-1]).to(x.device)]
+    angles=phase_angles(x.shape[-1]).to(x.device)
+    phasor=torch.complex(angles.cos(),angles.sin())
+    y=torch.fft.irfft(torch.fft.rfft(x.double(),dim=-1)*phasor,n=x.shape[-1],dim=-1)
+    return (torch.round(y*1e8)/1e8).float()
+
+@torch.no_grad()
+def raw_convolution_features(track,raw,mode='raw'):
+    outputs=[]
+    with precise_convolution(raw.device.type):
+        for chunk in raw.split(16) if len(raw) else [raw]:
+            count=len(chunk)
+            if count<16:chunk=torch.cat([chunk,raw.new_zeros((16-count,*raw.shape[1:]))])
+            x=torch.nan_to_num(chunk.double().flatten(2),nan=0.,posinf=1e5,neginf=-1e5).clamp(-1e5,1e5)
+            x=x-x[...,:1];x=x-x.mean(-1,keepdim=True)
+            if track in ('ad65','openbmi','longitudinal'):x=x-x.mean(1,keepdim=True)
+            power=x.square().mean((1,2),keepdim=True)
+            x=torch.where(power>1e-20,x/power.clamp_min(1e-20).sqrt(),torch.zeros_like(x)).clamp(-8,8)
+            x=(torch.round(x*1e8)/1e8).float()
+            outputs.append(transform_preprocessed(x,mode)[:count])
+    return torch.cat(outputs)
+
+class SharedTemporalConvolution(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.temporal=nn.Conv2d(1,16,(1,65),stride=(1,2),padding=(0,32),bias=False)
+        self.norm_temporal=nn.GroupNorm(4,16,eps=1e-5)
+        self.spatial=nn.Conv2d(16,32,(16,1),groups=16,bias=False)
+        self.norm_spatial=nn.GroupNorm(8,32,eps=1e-5)
+        self.dropout_spatial=nn.Dropout(.3)
+        self.depthwise=nn.Conv2d(32,32,(1,17),padding=(0,8),groups=32,bias=False)
+        self.pointwise=nn.Conv2d(32,64,1,bias=False)
+        self.norm_separable=nn.GroupNorm(8,64,eps=1e-5)
+        self.dropout_separable=nn.Dropout(.3)
+        self.embedding=nn.Linear(128,128)
+        self.norm_embedding=nn.LayerNorm(128,eps=1e-5)
+        self.dropout_embedding=nn.Dropout(.3)
+
+    def forward(self,x):
+        x=self.norm_temporal(self.temporal(x.unsqueeze(1)))
+        x=self.dropout_spatial(F.avg_pool2d(F.elu(self.norm_spatial(self.spatial(x))),(1,4)))
+        x=self.dropout_separable(F.avg_pool2d(F.elu(self.norm_separable(self.pointwise(self.depthwise(x)))),(1,8)))
+        x=x.squeeze(2);mean=x.mean(-1);std=((x-mean[...,None]).square().mean(-1)+1e-6).sqrt()
+        x=torch.cat([mean,std],dim=-1)
+        return self.dropout_embedding(self.norm_embedding(F.gelu(self.embedding(x))))

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/temporal_scale_math.py

@@ -0,0 +1,16 @@
+"""Fixed dilation placement for equally sized learned common temporal banks."""
+import torch
+from torch.nn import functional as F
+
+MODES = ('diverse', 'local', 'repeated65')
+DILATIONS = {'diverse': (1, 2, 4, 8), 'local': (1, 1, 1, 1),
+             'repeated65': (4, 4, 4, 4)}
+
+
+def temporal_scale_bank(x, weight, mode):
+    assert mode in MODES
+    assert x.ndim == 4 and x.shape[1] == 1
+    assert weight.shape == (16, 1, 1, 17)
+    return torch.cat([F.conv2d(x, weight[4*i:4*i+4], stride=(1, 2),
+                              padding=(0, 8*d), dilation=(1, d))
+                      for i, d in enumerate(DILATIONS[mode])], dim=1)

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

@@ -0,0 +1,3807 @@
+{
+  "history": [
+    {
+      "epoch": 1,
+      "joint_updates": 200,
+      "training_ce": {
+        "faced": 2.2063683569431305,
+        "tuev": 1.6311128944158555,
+        "ad65": 1.007968319952488,
+        "openbmi": 0.6983478009700775,
+        "longitudinal": 0.6436979472637177
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            312,
+            711,
+            228,
+            178,
+            1198,
+            12860
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              17,
+              225,
+              0,
+              0,
+              49,
+              0
+            ],
+            [
+              99,
+              184,
+              224,
+              0,
+              159,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              81,
+              0,
+              2
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              155,
+              264,
+              0,
+              97,
+              519,
+              12787
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.33482810164424515,
+            0.9418604651162791,
+            0.936,
+            0.9251193749095644
+          ],
+          "balanced_accuracy": 0.7050552581751975,
+          "accuracy": 0.8925550461677536,
+          "weighted_f1": 0.9080013242509555,
+          "macro_f1": 0.5413709133013715,
+          "kappa": 0.5781254368884994,
+          "samples": 15487,
+          "reward": 0.7050552581751975,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.1,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.5361111111111111,
+          "0.3": 0.5302469135802469,
+          "1.0": 0.11496913580246915
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.7050552581751975,
+          "0.3": 0.6667392517271272,
+          "1.0": 0.39495450934661464
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.8380952380952381,
+          "1.0": 0.5380952380952381
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8220454545454546,
+          "0.3": 0.8206818181818182,
+          "1.0": 0.5284090909090909
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.854407135732043,
+          "1.0": 0.6905466786056436
+        }
+      }
+    },
+    {
+      "epoch": 2,
+      "joint_updates": 400,
+      "training_ce": {
+        "faced": 2.1931438505649568,
+        "tuev": 1.2620423018932343,
+        "ad65": 0.828198854625225,
+        "openbmi": 0.6923283010721206,
+        "longitudinal": 0.5833807304501534
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            355,
+            736,
+            225,
+            178,
+            1176,
+            12817
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              17,
+              225,
+              0,
+              0,
+              49,
+              0
+            ],
+            [
+              99,
+              209,
+              221,
+              0,
+              137,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              80,
+              0,
+              3
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              198,
+              264,
+              0,
+              98,
+              519,
+              12743
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.3303437967115097,
+            0.9302325581395349,
+            0.936,
+            0.9219360439878455
+          ],
+          "balanced_accuracy": 0.7018393343699977,
+          "accuracy": 0.8894556724995157,
+          "weighted_f1": 0.9060795467857647,
+          "macro_f1": 0.5356941485591152,
+          "kappa": 0.5701427137051658,
+          "samples": 15487,
+          "reward": 0.7018393343699977,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.0,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.5370370370370371,
+          "0.3": 0.532253086419753,
+          "1.0": 0.1339506172839506
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.6961989153062914,
+          "0.3": 0.640511745429885,
+          "1.0": 0.48544253815977445
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.7714285714285714,
+          "1.0": 0.4603174603174603
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8227272727272728,
+          "0.3": 0.8204545454545453,
+          "1.0": 0.5947727272727272
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.854407135732043,
+          "1.0": 0.7111596994413579
+        }
+      }
+    },
+    {
+      "epoch": 3,
+      "joint_updates": 600,
+      "training_ce": {
+        "faced": 2.1848880529403685,
+        "tuev": 1.0958637952804566,
+        "ad65": 0.7546222493052482,
+        "openbmi": 0.6768594324588776,
+        "longitudinal": 0.5624203167855739
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            355,
+            736,
+            225,
+            178,
+            1176,
+            12817
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              17,
+              225,
+              0,
+              0,
+              49,
+              0
+            ],
+            [
+              99,
+              209,
+              221,
+              0,
+              137,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              80,
+              0,
+              3
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              198,
+              264,
+              0,
+              98,
+              519,
+              12743
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.3303437967115097,
+            0.9302325581395349,
+            0.936,
+            0.9219360439878455
+          ],
+          "balanced_accuracy": 0.7018393343699977,
+          "accuracy": 0.8894556724995157,
+          "weighted_f1": 0.9060795467857647,
+          "macro_f1": 0.5356941485591152,
+          "kappa": 0.5701427137051658,
+          "samples": 15487,
+          "reward": 0.7018393343699977,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.0,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.536111111111111,
+          "0.3": 0.5311728395061728,
+          "1.0": 0.14722222222222223
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.6973410670719856,
+          "0.3": 0.6116222078841141,
+          "1.0": 0.5542606648044619
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.8380952380952381,
+          "1.0": 0.5380952380952381
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8218181818181818,
+          "0.3": 0.8218181818181819,
+          "1.0": 0.6272727272727273
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.854407135732043,
+          "1.0": 0.7220835834562164
+        }
+      }
+    },
+    {
+      "epoch": 4,
+      "joint_updates": 800,
+      "training_ce": {
+        "faced": 2.1728256702423097,
+        "tuev": 1.0120218977332116,
+        "ad65": 0.7177016079425812,
+        "openbmi": 0.674168586730957,
+        "longitudinal": 0.563712527602911
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            356,
+            749,
+            220,
+            179,
+            1256,
+            12727
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              17,
+              225,
+              0,
+              0,
+              49,
+              0
+            ],
+            [
+              99,
+              178,
+              216,
+              0,
+              173,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              82,
+              0,
+              1
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              199,
+              308,
+              0,
+              97,
+              563,
+              12655
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.32286995515695066,
+            0.9534883720930233,
+            0.936,
+            0.9155693821444074
+          ],
+          "balanced_accuracy": 0.7034085527959131,
+          "accuracy": 0.8835797765868147,
+          "weighted_f1": 0.9018359469480304,
+          "macro_f1": 0.5306434463578182,
+          "kappa": 0.5559569368700095,
+          "samples": 15487,
+          "reward": 0.7034085527959131,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.1,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.5339506172839505,
+          "0.3": 0.528858024691358,
+          "1.0": 0.1572530864197531
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.7034085527959131,
+          "0.3": 0.638387604846299,
+          "1.0": 0.5466423916130195
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.7714285714285714,
+          "1.0": 0.5380952380952381
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8211363636363636,
+          "0.3": 0.8188636363636362,
+          "1.0": 0.6240909090909091
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.8548280111529184,
+          "1.0": 0.7136650470365047
+        }
+      }
+    },
+    {
+      "epoch": 5,
+      "joint_updates": 1000,
+      "training_ce": {
+        "faced": 2.156939595937729,
+        "tuev": 0.9532912164926529,
+        "ad65": 0.6678308106958866,
+        "openbmi": 0.6656227469444275,
+        "longitudinal": 0.5553989395499229
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            355,
+            736,
+            225,
+            178,
+            1176,
+            12817
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              17,
+              225,
+              0,
+              0,
+              49,
+              0
+            ],
+            [
+              99,
+              209,
+              221,
+              0,
+              137,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              80,
+              0,
+              3
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              198,
+              264,
+              0,
+              98,
+              519,
+              12743
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.3303437967115097,
+            0.9302325581395349,
+            0.936,
+            0.9219360439878455
+          ],
+          "balanced_accuracy": 0.7018393343699977,
+          "accuracy": 0.8894556724995157,
+          "weighted_f1": 0.9060795467857647,
+          "macro_f1": 0.5356941485591152,
+          "kappa": 0.5701427137051658,
+          "samples": 15487,
+          "reward": 0.7018393343699977,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.0,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.5328703703703703,
+          "0.3": 0.5294753086419752,
+          "1.0": 0.16049382716049382
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.6965131515798545,
+          "0.3": 0.6122567616529121,
+          "1.0": 0.5438449929533244
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.7238095238095238,
+          "1.0": 0.5063492063492063
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8218181818181818,
+          "0.3": 0.82,
+          "1.0": 0.6365909090909091
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.8547378235627308,
+          "1.0": 0.7235678520449172
+        }
+      }
+    },
+    {
+      "epoch": 6,
+      "joint_updates": 1200,
+      "training_ce": {
+        "faced": 2.158881115913391,
+        "tuev": 0.9296287760138512,
+        "ad65": 0.6055257871747017,
+        "openbmi": 0.654815536737442,
+        "longitudinal": 0.539940207451582
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            355,
+            736,
+            225,
+            178,
+            1176,
+            12817
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              17,
+              225,
+              0,
+              0,
+              49,
+              0
+            ],
+            [
+              99,
+              209,
+              221,
+              0,
+              137,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              80,
+              0,
+              3
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              198,
+              264,
+              0,
+              98,
+              519,
+              12743
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.3303437967115097,
+            0.9302325581395349,
+            0.936,
+            0.9219360439878455
+          ],
+          "balanced_accuracy": 0.7018393343699977,
+          "accuracy": 0.8894556724995157,
+          "weighted_f1": 0.9060795467857647,
+          "macro_f1": 0.5356941485591152,
+          "kappa": 0.5701427137051658,
+          "samples": 15487,
+          "reward": 0.7018393343699977,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.0,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.5339506172839505,
+          "0.3": 0.5294753086419752,
+          "1.0": 0.1566358024691358
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.6960189869295353,
+          "0.3": 0.634951665313274,
+          "1.0": 0.507892176650309
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.7238095238095238,
+          "1.0": 0.5349206349206349
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8211363636363636,
+          "0.3": 0.8163636363636364,
+          "1.0": 0.6504545454545454
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.8548280111529184,
+          "1.0": 0.7246592030673809
+        }
+      }
+    },
+    {
+      "epoch": 7,
+      "joint_updates": 1400,
+      "training_ce": {
+        "faced": 2.1526084542274475,
+        "tuev": 0.9077321618795395,
+        "ad65": 0.5842286013066769,
+        "openbmi": 0.649331571161747,
+        "longitudinal": 0.5448631934821606
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            355,
+            736,
+            225,
+            178,
+            1176,
+            12817
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              17,
+              225,
+              0,
+              0,
+              49,
+              0
+            ],
+            [
+              99,
+              209,
+              221,
+              0,
+              137,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              80,
+              0,
+              3
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              198,
+              264,
+              0,
+              98,
+              519,
+              12743
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.3303437967115097,
+            0.9302325581395349,
+            0.936,
+            0.9219360439878455
+          ],
+          "balanced_accuracy": 0.7018393343699977,
+          "accuracy": 0.8894556724995157,
+          "weighted_f1": 0.9060795467857647,
+          "macro_f1": 0.5356941485591152,
+          "kappa": 0.5701427137051658,
+          "samples": 15487,
+          "reward": 0.7018393343699977,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.0,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.5342592592592593,
+          "0.3": 0.5274691358024691,
+          "1.0": 0.15185185185185185
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.6979569714256594,
+          "0.3": 0.6311465306729623,
+          "1.0": 0.5484677104063674
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.7238095238095238,
+          "1.0": 0.47936507936507927
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8222727272727273,
+          "0.3": 0.8175,
+          "1.0": 0.6434090909090909
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.8547378235627308,
+          "1.0": 0.7329602809511528
+        }
+      }
+    },
+    {
+      "epoch": 8,
+      "joint_updates": 1600,
+      "training_ce": {
+        "faced": 2.146687477827072,
+        "tuev": 0.9064642637968063,
+        "ad65": 0.569061703234911,
+        "openbmi": 0.646725757420063,
+        "longitudinal": 0.5435716599225998
+      },
+      "validation": {
+        "faced": {
+          "class_counts": [
+            180,
+            180,
+            180,
+            180,
+            240,
+            180,
+            180,
+            180,
+            180
+          ],
+          "predicted_class_counts": [
+            153,
+            184,
+            179,
+            165,
+            289,
+            151,
+            186,
+            186,
+            187
+          ],
+          "confusion_matrix": [
+            [
+              95,
+              12,
+              3,
+              15,
+              17,
+              4,
+              12,
+              14,
+              8
+            ],
+            [
+              7,
+              94,
+              6,
+              14,
+              24,
+              9,
+              9,
+              6,
+              11
+            ],
+            [
+              7,
+              9,
+              105,
+              15,
+              18,
+              5,
+              7,
+              5,
+              9
+            ],
+            [
+              7,
+              19,
+              8,
+              67,
+              33,
+              8,
+              14,
+              13,
+              11
+            ],
+            [
+              11,
+              13,
+              18,
+              12,
+              128,
+              11,
+              14,
+              21,
+              12
+            ],
+            [
+              3,
+              9,
+              11,
+              7,
+              18,
+              100,
+              9,
+              14,
+              9
+            ],
+            [
+              6,
+              7,
+              9,
+              9,
+              20,
+              5,
+              105,
+              8,
+              11
+            ],
+            [
+              3,
+              12,
+              10,
+              19,
+              16,
+              7,
+              7,
+              100,
+              6
+            ],
+            [
+              14,
+              9,
+              9,
+              7,
+              15,
+              2,
+              9,
+              5,
+              110
+            ]
+          ],
+          "per_class_recall": [
+            0.5277777777777778,
+            0.5222222222222223,
+            0.5833333333333334,
+            0.37222222222222223,
+            0.5333333333333333,
+            0.5555555555555556,
+            0.5833333333333334,
+            0.5555555555555556,
+            0.6111111111111112
+          ],
+          "balanced_accuracy": 0.5382716049382716,
+          "accuracy": 0.5380952380952381,
+          "weighted_f1": 0.538881849093927,
+          "macro_f1": 0.5409170306503709,
+          "kappa": 0.4790822564791062,
+          "samples": 1680,
+          "reward": 0.5382716049382716,
+          "subjects": 20
+        },
+        "tuev": {
+          "class_counts": [
+            119,
+            291,
+            669,
+            86,
+            500,
+            13822
+          ],
+          "predicted_class_counts": [
+            358,
+            705,
+            226,
+            158,
+            1275,
+            12765
+          ],
+          "confusion_matrix": [
+            [
+              38,
+              38,
+              3,
+              0,
+              3,
+              37
+            ],
+            [
+              0,
+              225,
+              0,
+              0,
+              66,
+              0
+            ],
+            [
+              96,
+              178,
+              222,
+              0,
+              170,
+              3
+            ],
+            [
+              3,
+              0,
+              0,
+              83,
+              0,
+              0
+            ],
+            [
+              0,
+              0,
+              1,
+              0,
+              468,
+              31
+            ],
+            [
+              221,
+              264,
+              0,
+              75,
+              568,
+              12694
+            ]
+          ],
+          "per_class_recall": [
+            0.31932773109243695,
+            0.7731958762886598,
+            0.33183856502242154,
+            0.9651162790697675,
+            0.936,
+            0.9183909709159311
+          ],
+          "balanced_accuracy": 0.7073115703982028,
+          "accuracy": 0.8865500096855428,
+          "weighted_f1": 0.9041877803178755,
+          "macro_f1": 0.5449633898996022,
+          "kappa": 0.5636471384380517,
+          "samples": 15487,
+          "reward": 0.7073115703982028,
+          "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": [
+            1987,
+            2413
+          ],
+          "confusion_matrix": [
+            [
+              1705,
+              495
+            ],
+            [
+              282,
+              1918
+            ]
+          ],
+          "per_class_recall": [
+            0.775,
+            0.8718181818181818
+          ],
+          "balanced_accuracy": 0.823409090909091,
+          "accuracy": 0.8234090909090909,
+          "weighted_f1": 0.8229942886302098,
+          "macro_f1": 0.82299428863021,
+          "kappa": 0.6468181818181817,
+          "samples": 4400,
+          "subject_scores": {
+            "19": 0.875,
+            "35": 0.95,
+            "34": 0.6699999999999999,
+            "51": 0.795,
+            "20": 0.8425,
+            "44": 0.9425,
+            "24": 0.615,
+            "15": 0.8875,
+            "31": 0.9099999999999999,
+            "26": 0.835,
+            "23": 0.735
+          },
+          "reward": 0.823409090909091,
+          "subjects": 11
+        },
+        "longitudinal": {
+          "class_counts": [
+            4260,
+            4158
+          ],
+          "predicted_class_counts": [
+            4552,
+            3866
+          ],
+          "confusion_matrix": [
+            [
+              3795,
+              465
+            ],
+            [
+              757,
+              3401
+            ]
+          ],
+          "per_class_recall": [
+            0.8908450704225352,
+            0.817941317941318
+          ],
+          "balanced_accuracy": 0.8543931941819266,
+          "accuracy": 0.8548348776431456,
+          "weighted_f1": 0.8545986797881616,
+          "macro_f1": 0.8545161723182699,
+          "kappa": 0.7093827910518298,
+          "samples": 8418,
+          "subject_scores": {
+            "sub-G2021": 0.8627525887522267,
+            "sub-G2007": 0.816860103413505,
+            "sub-G2019": 0.852993824374467,
+            "sub-G2031": 0.828332994328064,
+            "sub-G2015": 0.9043525361474528,
+            "sub-CTR002": 0.9934852728970376,
+            "sub-G2011": 0.8100294180322551,
+            "sub-G2035": 0.9598833152678935,
+            "sub-CTR003": 0.6680194805194806
+          },
+          "reward": 0.855189948192487,
+          "subjects": 9
+        }
+      },
+      "blend_strengths": {
+        "faced": 0.0,
+        "tuev": 0.1,
+        "ad65": 0.0,
+        "openbmi": 0.0,
+        "longitudinal": 0.0
+      },
+      "blend_validation_scores": {
+        "faced": {
+          "0.0": 0.5382716049382716,
+          "0.1": 0.5347222222222222,
+          "0.3": 0.5300925925925927,
+          "1.0": 0.16512345679012347
+        },
+        "tuev": {
+          "0.0": 0.7018393343699977,
+          "0.1": 0.7073115703982028,
+          "0.3": 0.6294631409568789,
+          "1.0": 0.5334879433344161
+        },
+        "ad65": {
+          "0.0": 0.8380952380952381,
+          "0.1": 0.8380952380952381,
+          "0.3": 0.7238095238095238,
+          "1.0": 0.47936507936507927
+        },
+        "openbmi": {
+          "0.0": 0.823409090909091,
+          "0.1": 0.8220454545454544,
+          "0.3": 0.819318181818182,
+          "1.0": 0.6654545454545455
+        },
+        "longitudinal": {
+          "0.0": 0.855189948192487,
+          "0.1": 0.8550985739234811,
+          "0.3": 0.8547378235627308,
+          "1.0": 0.7352847229128177
+        }
+      }
+    }
+  ],
+  "settings": {
+    "condition": "all",
+    "model_seed": 543,
+    "sampling_seed": 2123,
+    "patient_seed": 656,
+    "epochs": 30,
+    "updates_per_epoch": 200,
+    "output": "/workspace/research/experiments543/all_full"
+  },
+  "source": "/workspace/research/experiments508/local_full/epoch-001",
+  "plan_sha256": "5a83e3f10d0a62f83a9ebb159dd299d4476b948f207141b40d3a9b49d6235a2e",
+  "trainer_sha256": "99c705698c99dc3f2f4fe4cf3fd6ce6cad93ecb297df934593ed2fd289d8c247",
+  "source_weights_sha256": "bfd88b74ab99fe2a9c3cf0bb6013baf12fff641dade9a9308195490b8a50ba69",
+  "initial_model_sha256": "dbac35daf6e1e9da54a5a30b4f50fa44cdace06ba9e8bd925a2495b663400e7c",
+  "input_sha256": {
+    "/workspace/data/faced/train/manifest.json": "24f7c5c2165944b3544cd0935cc3dc84b9d9df9eb4fa347656d5135c0824ab4b",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/faced-train-raw.npy": "d600f6c96284f2432f1b36a4903edd10f2caacf709e59daf8b49efddcaea4735",
+    "/workspace/data/faced/val/manifest.json": "a3074299e9ebd90194bf2ca365529d5ce4806adbe63fb45fb8818ce7b00c70c5",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/faced-val-raw.npy": "6289496956b9995e33f5555426b9e6803364c75bdb1788b58d16236f5d2ab46d",
+    "/workspace/research/complete508_source_cache_v1/faced-val-complete508-logits.npy": "b196c32cda7a22e921492e3373a9f63734c9cad5e40fbcf602297bf3e4396af4",
+    "/workspace/research/experiments508/local_full/faced-e001.npy": "9f79fb40cb09b2b0a309d3ab5f83c468a57db0e9a76d23b76a55f536c668d37f",
+    "/workspace/data/tuev/train/manifest.json": "49b7880052e6d093633e6e03d52bfd7df9084271ebf8e4f60e4fbe12da398354",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/tuev-train-raw.npy": "bd64f10c03bf8a580a1ea9a8eed99633f189f375eb4f6eb2e16974980a158209",
+    "/workspace/data/tuev/val/manifest.json": "b3e38b33be594d2e5904000be876a8f85b96869dc26c24f1dcc07444c476c5d3",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/tuev-val-raw.npy": "6baddc47cc0aafb2e61593761d203e9c354de36741abc799a12f5cdcb5fecc9e",
+    "/workspace/research/complete508_source_cache_v1/tuev-val-complete508-logits.npy": "eb92aca62daab28761bc7cc607f8092d89c8ad212cc9a9928a15971ce707e14e",
+    "/workspace/research/experiments508/local_full/tuev-e001.npy": "edf6a11b71729469ddaf00b7ac8ecb78bdfdcc0cb88c035d9e7d61ec81f47154",
+    "/workspace/data/ad65/train/manifest.json": "f11857b9ef2fda74fef95b5a692afcc4ad6df740f014223780e04580e69dd93e",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/ad65-train-raw.npy": "de33a3ca6f41cebc1c5611bcf434efea109ef68303ad9052a77f5179eeaefef9",
+    "/workspace/data/ad65/val/manifest.json": "81f42305bb52728391c7cf2f07cd550c13fc7934b8bd42770252d966dac37a05",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/ad65-val-raw.npy": "aaf0416dd74d5651906b84f1ad13094f4a3f1921c70298f581bcf863832e73df",
+    "/workspace/research/complete508_source_cache_v1/ad65-val-complete508-logits.npy": "6ddaaac7f2c4acc252b10ee108286cf6ecd498235363106237bbfc96ab2acde1",
+    "/workspace/research/experiments508/local_full/ad65-e001.npy": "7a3b74c58580b7ba952322bf6d527ebc9a40a6e04c7cdbbaea14e84a7a298d54",
+    "/workspace/data/openbmi/train/manifest.json": "35446de7b6e3e536f735e935c7eb74cc720f198a60d700da1db5fa39f315f5d5",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/openbmi-train-raw.npy": "4767e55717e09cf1cdb68344677f4de18a02856bbdbfe4038fdf3a151cce2c13",
+    "/workspace/data/openbmi/val/manifest.json": "56622533f8fa28c2f7e1a619b04b2350f902494e9de1e58fa5e3abea59f8259c",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/openbmi-val-raw.npy": "d8d8e65bfa8a93bbb37bd50985af9db9a352719c9f7fefd7da4118dde98d4a24",
+    "/workspace/research/complete508_source_cache_v1/openbmi-val-complete508-logits.npy": "8e483f018f275ee243846586cac040a6ca48b2c102d1d0de960d871daa0b43cb",
+    "/workspace/research/experiments508/local_full/openbmi-e001.npy": "562af8dbfd72b693c67f86ee450e0d4259c63000ba8e50d756cf5c446193224e",
+    "/workspace/data/longitudinal/train/manifest.json": "6ec8c8090a099cd4e4bf5faaf4bf97be7701916f7333a4e3b5c87b1d0b9f1acc",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/longitudinal-train-raw.npy": "180d76b0980b4a3aa2d97cc9c2860848df5a92af1f46e671f7718ae7c5c505e5",
+    "/workspace/data/longitudinal/val/manifest.json": "fae612fca74139815b5b53e20ed7af7f50083026b0126962bdd5f954b9047edb",
+    "/workspace/research/shared_temporal_convolution_443_cache_v1/longitudinal-val-raw.npy": "1a9aaa4f3597676ef858bf2435c4009cba453f9aa88e95aba034e07e78d65bd9",
+    "/workspace/research/complete508_source_cache_v1/longitudinal-val-complete508-logits.npy": "f51e4cd91a9062cb514779a49d791d182210692af0ffeed959bd80c5a50c0d2f",
+    "/workspace/research/experiments508/local_full/longitudinal-e001.npy": "cef9aa2faa49f53ab68cdfc79f7f022e183c0c2a658d1f65efc438ed4940d3d2"
+  },
+  "all_tracks_update_shared_backbone": true,
+  "all_five_validation_splits_evaluated": true,
+  "all1592_source_states_fixed": true,
+  "all_five_source_fallback_arrays_exact": true,
+  "shared_gradient_audit": {
+    "faced": {
+      "adapters.faced.weight": 0.11062344163656235,
+      "backbone.temporal.weight": 0.17392498254776,
+      "backbone.norm_temporal.weight": 0.011979063972830772,
+      "backbone.norm_temporal.bias": 0.036790911108255386,
+      "backbone.spatial.weight": 0.06707913428544998,
+      "backbone.norm_spatial.weight": 0.011345813982188702,
+      "backbone.norm_spatial.bias": 0.02745184488594532,
+      "backbone.depthwise.weight": 0.08860281854867935,
+      "backbone.pointwise.weight": 0.10825546085834503,
+      "backbone.norm_separable.weight": 0.020657798275351524,
+      "backbone.norm_separable.bias": 0.025895925238728523,
+      "backbone.embedding.weight": 0.3844121992588043,
+      "backbone.embedding.bias": 0.0778844878077507,
+      "backbone.norm_embedding.weight": 0.017623893916606903,
+      "backbone.norm_embedding.bias": 0.017910070717334747,
+      "heads.faced.weight": 0.8972694873809814,
+      "heads.faced.bias": 0.0615614652633667
+    },
+    "tuev": {
+      "adapters.tuev.weight": 0.09146258980035782,
+      "backbone.temporal.weight": 0.20790860056877136,
+      "backbone.norm_temporal.weight": 0.019124427810311317,
+      "backbone.norm_temporal.bias": 0.03587087616324425,
+      "backbone.spatial.weight": 0.1076166108250618,
+      "backbone.norm_spatial.weight": 0.018160680308938026,
+      "backbone.norm_spatial.bias": 0.03431427851319313,
+      "backbone.depthwise.weight": 0.12570388615131378,
+      "backbone.pointwise.weight": 0.18391667306423187,
+      "backbone.norm_separable.weight": 0.02694922313094139,
+      "backbone.norm_separable.bias": 0.03895087167620659,
+      "backbone.embedding.weight": 0.5857461094856262,
+      "backbone.embedding.bias": 0.11499238759279251,
+      "backbone.norm_embedding.weight": 0.027521314099431038,
+      "backbone.norm_embedding.bias": 0.02828020043671131,
+      "heads.tuev.weight": 1.41971755027771,
+      "heads.tuev.bias": 0.11935191601514816
+    },
+    "ad65": {
+      "adapters.ad65.weight": 0.07960694283246994,
+      "backbone.temporal.weight": 0.19772127270698547,
+      "backbone.norm_temporal.weight": 0.01653403416275978,
+      "backbone.norm_temporal.bias": 0.01979927346110344,
+      "backbone.spatial.weight": 0.08738940954208374,
+      "backbone.norm_spatial.weight": 0.016772322356700897,
+      "backbone.norm_spatial.bias": 0.021332213655114174,
+      "backbone.depthwise.weight": 0.10752315074205399,
+      "backbone.pointwise.weight": 0.1556306779384613,
+      "backbone.norm_separable.weight": 0.018312150612473488,
+      "backbone.norm_separable.bias": 0.017384428530931473,
+      "backbone.embedding.weight": 0.36892786622047424,
+      "backbone.embedding.bias": 0.05737750604748726,
+      "backbone.norm_embedding.weight": 0.015667730942368507,
+      "backbone.norm_embedding.bias": 0.013248385861515999,
+      "heads.ad65.weight": 0.8126062154769897,
+      "heads.ad65.bias": 0.0498795211315155
+    },
+    "openbmi": {
+      "adapters.openbmi.weight": 0.1328270435333252,
+      "backbone.temporal.weight": 0.1653299182653427,
+      "backbone.norm_temporal.weight": 0.01209245529025793,
+      "backbone.norm_temporal.bias": 0.027509210631251335,
+      "backbone.spatial.weight": 0.06978999078273773,
+      "backbone.norm_spatial.weight": 0.014218584634363651,
+      "backbone.norm_spatial.bias": 0.03649844229221344,
+      "backbone.depthwise.weight": 0.09271294623613358,
+      "backbone.pointwise.weight": 0.12612847983837128,
+      "backbone.norm_separable.weight": 0.024974927306175232,
+      "backbone.norm_separable.bias": 0.030704054981470108,
+      "backbone.embedding.weight": 0.47488367557525635,
+      "backbone.embedding.bias": 0.10317503660917282,
+      "backbone.norm_embedding.weight": 0.020673606544733047,
+      "backbone.norm_embedding.bias": 0.026708491146564484,
+      "heads.openbmi.weight": 1.3107001781463623,
+      "heads.openbmi.bias": 0.11629775911569595
+    },
+    "longitudinal": {
+      "adapters.longitudinal.weight": 0.19808974862098694,
+      "backbone.temporal.weight": 0.2574745714664459,
+      "backbone.norm_temporal.weight": 0.017279857769608498,
+      "backbone.norm_temporal.bias": 0.0480697862803936,
+      "backbone.spatial.weight": 0.09192802011966705,
+      "backbone.norm_spatial.weight": 0.016134388744831085,
+      "backbone.norm_spatial.bias": 0.026977606117725372,
+      "backbone.depthwise.weight": 0.10477544367313385,
+      "backbone.pointwise.weight": 0.14035655558109283,
+      "backbone.norm_separable.weight": 0.0211783479899168,
+      "backbone.norm_separable.bias": 0.02369631826877594,
+      "backbone.embedding.weight": 0.39398816227912903,
+      "backbone.embedding.bias": 0.0699661523103714,
+      "backbone.norm_embedding.weight": 0.01660672016441822,
+      "backbone.norm_embedding.bias": 0.019186971709132195,
+      "heads.longitudinal.weight": 1.0706279277801514,
+      "heads.longitudinal.bias": 0.08428003638982773
+    }
+  },
+  "raw_checks": {
+    "faced": {
+      "train_windows": 17,
+      "stateless_raw_features_exact": true
+    },
+    "tuev": {
+      "train_windows": 17,
+      "stateless_raw_features_exact": true
+    },
+    "ad65": {
+      "train_windows": 17,
+      "stateless_raw_features_exact": true
+    },
+    "openbmi": {
+      "train_windows": 17,
+      "stateless_raw_features_exact": true
+    },
+    "longitudinal": {
+      "train_windows": 17,
+      "stateless_raw_features_exact": true
+    }
+  },
+  "prediction_sha256": {
+    "faced": "9f79fb40cb09b2b0a309d3ab5f83c468a57db0e9a76d23b76a55f536c668d37f",
+    "tuev": "ed541862cb2f370ca9c4428a5ed8eb903858279f5bf6cf1439ee83d46c0df783",
+    "ad65": "7a3b74c58580b7ba952322bf6d527ebc9a40a6e04c7cdbbaea14e84a7a298d54",
+    "openbmi": "562af8dbfd72b693c67f86ee450e0d4259c63000ba8e50d756cf5c446193224e",
+    "longitudinal": "cef9aa2faa49f53ab68cdfc79f7f022e183c0c2a658d1f65efc438ed4940d3d2"
+  },
+  "optimizer_group_parameter_names": [
+    [
+      "adapters.faced.activation_groups_projection.weight",
+      "adapters.tuev.activation_groups_projection.weight",
+      "adapters.ad65.activation_groups_projection.weight",
+      "adapters.openbmi.activation_groups_projection.weight",
+      "adapters.longitudinal.activation_groups_projection.weight",
+      "backbone.activation_groups_encoder.temporal.weight",
+      "backbone.activation_groups_encoder.norm_temporal.weight",
+      "backbone.activation_groups_encoder.norm_temporal.bias",
+      "backbone.activation_groups_encoder.spatial.weight",
+      "backbone.activation_groups_encoder.norm_spatial.weight",
+      "backbone.activation_groups_encoder.norm_spatial.bias",
+      "backbone.activation_groups_encoder.depthwise.weight",
+      "backbone.activation_groups_encoder.pointwise.weight",
+      "backbone.activation_groups_encoder.norm_separable.weight",
+      "backbone.activation_groups_encoder.norm_separable.bias",
+      "backbone.activation_groups_encoder.embedding.weight",
+      "backbone.activation_groups_encoder.embedding.bias",
+      "backbone.activation_groups_encoder.norm_embedding.weight",
+      "backbone.activation_groups_encoder.norm_embedding.bias",
+      "activation_groups_heads.faced.projection.weight",
+      "activation_groups_heads.faced.projection.bias",
+      "activation_groups_heads.tuev.projection.weight",
+      "activation_groups_heads.tuev.projection.bias",
+      "activation_groups_heads.ad65.projection.weight",
+      "activation_groups_heads.ad65.projection.bias",
+      "activation_groups_heads.openbmi.projection.weight",
+      "activation_groups_heads.openbmi.projection.bias",
+      "activation_groups_heads.longitudinal.projection.weight",
+      "activation_groups_heads.longitudinal.projection.bias"
+    ]
+  ],
+  "no_cross_common_head_selection": true,
+  "training_uses_source_logits": false
+}

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/submission/weighted_pattern_model.py

@@ -0,0 +1,25 @@
+"""One common weighted-pattern refinement, jointly trained on five EEG tracks."""
+from multitaper_model import *
+SourceHybridModel=HybridModel
+FEATURE_TRACKS=('faced','openbmi','longitudinal')
+class WeightedPatternReadout(nn.Module):
+ def __init__(self,classes,scale):
+  super().__init__();self.projection=nn.Linear(128,classes);nn.init.zeros_(self.projection.weight);nn.init.zeros_(self.projection.bias);self.register_buffer('output_scale',scale.detach().clone());self.register_buffer('correction_gain',torch.tensor(1.))
+class HybridModel(SourceHybridModel):
+ def __init__(self,weighted_pattern_refinement=False,weighted_pattern_mode='weighted',weighted_pattern_enabled=1.,**kwargs):
+  super().__init__(**kwargs);assert weighted_pattern_refinement and weighted_pattern_mode in ['weighted','plain','shuffled'];self.weighted_pattern_mode=weighted_pattern_mode
+  for t in TRACKS:
+   dimension=130*SPECS[t][0] if t in FEATURE_TRACKS else self.adapters[t].multitaper_projection.in_features;self.adapters[t].weighted_pattern_normalizer=Standardize(dimension);self.adapters[t].weighted_pattern_projection=nn.Linear(dimension,128)
+  self.backbone.weighted_pattern_encoder=nn.Sequential(nn.Linear(128,256),nn.LayerNorm(256),nn.GELU(),nn.Dropout(.3),nn.Linear(256,128),nn.LayerNorm(128));self.backbone.register_buffer('weighted_pattern_enabled',torch.tensor(float(weighted_pattern_enabled)));self.weighted_pattern_heads=nn.ModuleDict({t:WeightedPatternReadout(SPECS[t][2],self.heads[t].output_scale) for t in TRACKS})
+ def weighted_pattern_features(self,t,x,features=None):
+  if t not in FEATURE_TRACKS:return super().multitaper_features(t,x)
+  from weighted_ordinal_features import weighted_ordinal_features
+  return weighted_ordinal_features(t,x)[self.weighted_pattern_mode]
+ def weighted_pattern_embedding(self,t,values):
+  with torch.autocast(values.device.type,enabled=False):return self.backbone.weighted_pattern_encoder(self.adapters[t].weighted_pattern_projection(self.adapters[t].weighted_pattern_normalizer(values.float())))
+ def weighted_pattern_predict(self,t,values,prior,gain=None,return_standalone=False):
+  with torch.autocast(values.device.type,enabled=False):
+   h=self.weighted_pattern_heads[t];standalone=h.projection(self.weighted_pattern_embedding(t,values))*self.backbone.weighted_pattern_enabled;g=h.correction_gain if gain is None else gain;result=prior.float()+(g*h.output_scale)*standalone
+  return (result,standalone) if return_standalone else result
+ def forward(self,t,x,features=None,covariances=None,covariance_features=None):
+  prior=super().forward(t,x,features,covariances=covariances,covariance_features=covariance_features);return self.weighted_pattern_predict(t,self.weighted_pattern_features(t,x,features=features),prior)

tasks/brain-computer-interface-decoding/brain-computer-interface-decoding-astra-xhigh-1h100-48h-20261031a/finalization/trajectory.jsonl

@@ -0,0 +1,27 @@
+{"type":"thread.started","thread_id":"01a19351-dcd4-7b31-83ad-611e1e0b6c67"}
+{"type":"item.completed","item":{"id":"item_0","type":"error","message":"`[features].use_legacy_landlock` is deprecated and will be removed soon. (Remove this setting to stop opting into the legacy Linux sandbox behavior.)"}}
+{"type":"turn.started"}
+{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"I’ll finalize the already verified experiment 543 package. I’ll use the existing proof records and static file checks only, then stop."}}
+{"type":"item.started","item":{"id":"item_2","type":"command_execution","command":"/bin/sh -lc pwd","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_2","type":"command_execution","command":"/bin/sh -lc pwd","aggregated_output":"/workspace\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_3","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/research/published_state.json'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_3","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/research/published_state.json'","aggregated_output":"{\n  \"source\": \"/workspace/research/experiments543/all_full/epoch-008\",\n  \"validation\": {\n    \"faced\": 0.5382716049382716,\n    \"tuev\": 0.7073115703982028,\n    \"ad65\": 0.8380952380952381,\n    \"openbmi\": 0.823409090909091,\n    \"longitudinal\": 0.855189948192487\n  },\n  \"weights_sha256\": \"fb1405db77c975a547acc95ca50fd8113aa42134a9b52b167843e4fa442ee61e\",\n  \"full_inference_validation_matches\": true,\n  \"validation_evidence\": \"publication-fb1405db77c9-verified.json\",\n  \"readonly_relocation_passed\": true,\n  \"relocation_evidence\": \"publication-fb1405db77c9-relocation.json\",\n  \"verification_status\": \"complete\",\n  \"validation_scope\": {\n    \"raw_reverified_tracks\": [\n      \"faced\",\n      \"tuev\",\n      \"ad65\",\n      \"openbmi\",\n      \"longitudinal\"\n    ],\n    \"inherited_raw_evidence_tracks\": []\n  },\n  \"relocation_scope\": \"Direct uid1000 all-five readonly relocation with fresh IDs, shuffled rows and zeros.\",\n  \"verified_at\": \"2026-11-02T13:09:18.828123+00:00\",\n  \"prepublication_verification\": true,\n  \"fresh_stage_replay_audit\": \"/workspace/research/activation-groups-full-review-all_full-replay-audit.json\",\n  \"source_joint_ancestry_verified\": true,\n  \"this_stage_allfive_update_common\": true,\n  \"contract_check_passed\": true,\n  \"contract_checked_during_atomic_publication\": true\n}\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_4","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/contract.md'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_4","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/contract.md'","aggregated_output":"# BCI five-track shared submission v2\n\nKeep one complete package under /workspace/submission, including infer.sh,\narchitecture configuration, code and weights. One trainable EEG backbone must\nserve all five tracks; input adapters and classification heads may be task-specific.\nThe backbone must be trained jointly on all five training splits. Initialization\nmay be random or from the task-provided audited checkpoint allowlist. Package\ncontents must not contain symlinks. The package must run after relocation.\n\nInvocation: bash infer.sh INPUT_DIR OUTPUT_DIR.\nINPUT_DIR/manifest.json contains schema=bci-input-v1, track, config, and samples.\nEach sample is {\"id\":\"opaque\",\"path\":\"shard-000000.npy\",\"index\":0}.\nNumPy shards have shape [N,C,S,200], in microvolts. Track C/S:\nfaced 32/10, tuev 16/5, ad65 19/10, openbmi 62/4, longitudinal 58/2.\nThe baseline scales input by 1/100. No labels, subjects or source filenames are\npart of test inputs. Support unseen IDs, arbitrary order and sample counts.\n\nWrite OUTPUT_DIR/predictions.jsonl, exactly one row per ID:\n{\"id\":\"opaque\",\"probabilities\":[0.2,0.8]}.\nClass counts: 9/6/3/2/2 respectively. Values must be finite in [0,1],\nsum to 1 within 1e-5, and use the documented class order. Missing, duplicate,\nunknown IDs or invalid probabilities invalidate that track (reward 0).\n\nRuntime: PyTorch 2.8.0, dependencies in requirements.txt, one GPU, 64 GiB RAM,\ntwo hours maximum per track, no network, unprivileged user, package/input\nread-only and output writable. Inference cannot use labels, external caches or\nworkspace files. No training/adaptation on evaluation batches.\n\nEach track is independently scored in [0,1]; no scalar aggregate.\nFACED/TUEV: balanced accuracy, with weighted F1 and Cohen kappa.\nAD: arithmetic mean of window probabilities per subject, then subject-level\nbalanced accuracy (window metrics additionally reported).\nOpenBMI: mean of subject-level balanced accuracies over all each subject's trials.\nLongitudinal: balanced accuracy per subject/session, mean across sessions within\nsubject, then mean across subjects. Infrastructure failures produce no reward.\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_5","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport json,os\np='/workspace/research/published_state.json'\nx=json.load(open(p))\nprint('published_state_keys',list(x))\nfor k,v in x.items():\n if isinstance(v,(str,int,float,bool)) or v is None: print(k, v)\nprint('submission_exists',os.path.isdir('/workspace/submission'))\nprint('submission_files',sorted(os.listdir('/workspace/submission')))\np='/workspace/research/publication-fb1405db77c9-installed-closure.json'\nx=json.load(open(p)); print('closure_keys',list(x)); print('file_count',len(x.get('all_package_file_sha256',{})))\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_5","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport json,os\np='/workspace/research/published_state.json'\nx=json.load(open(p))\nprint('published_state_keys',list(x))\nfor k,v in x.items():\n if isinstance(v,(str,int,float,bool)) or v is None: print(k, v)\nprint('submission_exists',os.path.isdir('/workspace/submission'))\nprint('submission_files',sorted(os.listdir('/workspace/submission')))\np='/workspace/research/publication-fb1405db77c9-installed-closure.json'\nx=json.load(open(p)); print('closure_keys',list(x)); print('file_count',len(x.get('all_package_file_sha256',{})))\nPY\"","aggregated_output":"published_state_keys ['source', 'validation', 'weights_sha256', 'full_inference_validation_matches', 'validation_evidence', 'readonly_relocation_passed', 'relocation_evidence', 'verification_status', 'validation_scope', 'relocation_scope', 'verified_at', 'prepublication_verification', 'fresh_stage_replay_audit', 'source_joint_ancestry_verified', 'this_stage_allfive_update_common', 'contract_check_passed', 'contract_checked_during_atomic_publication']\nsource /workspace/research/experiments543/all_full/epoch-008\nweights_sha256 fb1405db77c975a547acc95ca50fd8113aa42134a9b52b167843e4fa442ee61e\nfull_inference_validation_matches True\nvalidation_evidence publication-fb1405db77c9-verified.json\nreadonly_relocation_passed True\nrelocation_evidence publication-fb1405db77c9-relocation.json\nverification_status complete\nrelocation_scope Direct uid1000 all-five readonly relocation with fresh IDs, shuffled rows and zeros.\nverified_at 2026-11-02T13:09:18.828123+00:00\nprepublication_verification True\nfresh_stage_replay_audit /workspace/research/activation-groups-full-review-all_full-replay-audit.json\nsource_joint_ancestry_verified True\nthis_stage_allfive_update_common True\ncontract_check_passed True\ncontract_checked_during_atomic_publication True\nsubmission_exists True\nsubmission_files ['MODEL_CARD.md', 'activation_groups_math.py', 'additive_hinge_features.py', 'additive_hinge_geometry.py', 'additive_hinge_kernel.py', 'alpha_features.py', 'candidate_temporal_basis_model.py', 'channel_attention_math.py', 'confidence_model.py', 'config.json', 'coupling_features.py', 'covariances.py', 'data.py', 'envelope_features.py', 'features.py', 'frequency_features.py', 'gradient_protection.py', 'infer.py', 'infer.sh', 'learned_filter_temporal_basis.py', 'legacy_model.py', 'local_channel_features.py', 'model.py', 'multitaper_covariance_features.py', 'multitaper_model.py', 'native_log_covariance_features.py', 'ordinal_features.py', 'partial_covariance_features.py', 'phase_features.py', 'requirements.txt', 'shared_activation_groups_parent_model.py', 'shared_additive_hinge_model.py', 'shared_dual_readout_model.py', 'shared_expert_routing_math.py', 'shared_expert_routing_model.py', 'shared_spectral_features.py', 'shared_spectral_filter_model.py', 'shared_temporal_basis_model.py', 'short_context_features.py', 'student_features.py', 'tangent_features.py', 'temporal_convolution_math.py', 'temporal_scale_math.py', 'training.json', 'weighted_ordinal_features.py', 'weighted_pattern_model.py', 'weights.pt']\nclosure_keys ['completed_at', 'source', 'weights_sha256', 'registration', 'registration_sha256', 'all_package_file_sha256', 'all_registered_proof_hashes_exact', 'direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication', 'installed_scores']\nfile_count 47\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_6","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/contract.md'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_6","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/contract.md'","aggregated_output":"# BCI five-track shared submission v2\n\nKeep one complete package under /workspace/submission, including infer.sh,\narchitecture configuration, code and weights. One trainable EEG backbone must\nserve all five tracks; input adapters and classification heads may be task-specific.\nThe backbone must be trained jointly on all five training splits. Initialization\nmay be random or from the task-provided audited checkpoint allowlist. Package\ncontents must not contain symlinks. The package must run after relocation.\n\nInvocation: bash infer.sh INPUT_DIR OUTPUT_DIR.\nINPUT_DIR/manifest.json contains schema=bci-input-v1, track, config, and samples.\nEach sample is {\"id\":\"opaque\",\"path\":\"shard-000000.npy\",\"index\":0}.\nNumPy shards have shape [N,C,S,200], in microvolts. Track C/S:\nfaced 32/10, tuev 16/5, ad65 19/10, openbmi 62/4, longitudinal 58/2.\nThe baseline scales input by 1/100. No labels, subjects or source filenames are\npart of test inputs. Support unseen IDs, arbitrary order and sample counts.\n\nWrite OUTPUT_DIR/predictions.jsonl, exactly one row per ID:\n{\"id\":\"opaque\",\"probabilities\":[0.2,0.8]}.\nClass counts: 9/6/3/2/2 respectively. Values must be finite in [0,1],\nsum to 1 within 1e-5, and use the documented class order. Missing, duplicate,\nunknown IDs or invalid probabilities invalidate that track (reward 0).\n\nRuntime: PyTorch 2.8.0, dependencies in requirements.txt, one GPU, 64 GiB RAM,\ntwo hours maximum per track, no network, unprivileged user, package/input\nread-only and output writable. Inference cannot use labels, external caches or\nworkspace files. No training/adaptation on evaluation batches.\n\nEach track is independently scored in [0,1]; no scalar aggregate.\nFACED/TUEV: balanced accuracy, with weighted F1 and Cohen kappa.\nAD: arithmetic mean of window probabilities per subject, then subject-level\nbalanced accuracy (window metrics additionally reported).\nOpenBMI: mean of subject-level balanced accuracies over all each subject's trials.\nLongitudinal: balanced accuracy per subject/session, mean across sessions within\nsubject, then mean across subjects. Infrastructure failures produce no reward.\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_7","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport json,pathlib,hashlib\nr=pathlib.Path('/workspace/submission')\nfor n in ['infer.sh','requirements.txt']:\n print(n); print((r/n).read_text())\nx=json.loads((r/'config.json').read_text()); print('config_keys',list(x)); print('model_card', (r/'MODEL_CARD.md').read_text()[:5500])\np=pathlib.Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nprint('closure_sha256',hashlib.sha256(p.read_bytes()).hexdigest())\nx=json.loads(p.read_text()); print('scores',x.get('installed_scores')); print('source',x.get('source')); print('recorded_pass',x.get('direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'))\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_7","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport json,pathlib,hashlib\nr=pathlib.Path('/workspace/submission')\nfor n in ['infer.sh','requirements.txt']:\n print(n); print((r/n).read_text())\nx=json.loads((r/'config.json').read_text()); print('config_keys',list(x)); print('model_card', (r/'MODEL_CARD.md').read_text()[:5500])\np=pathlib.Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nprint('closure_sha256',hashlib.sha256(p.read_bytes()).hexdigest())\nx=json.loads(p.read_text()); print('scores',x.get('installed_scores')); print('source',x.get('source')); print('recorded_pass',x.get('direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'))\nPY\"","aggregated_output":"infer.sh\n#!/usr/bin/env bash\nset -euo pipefail\nexec python \"$(dirname -- \"$0\")/infer.py\" \"$1\" \"$2\"\n\nrequirements.txt\nnumpy\nscipy\ntorch==2.8.0\nbraindecode==1.8.1\n\nconfig_keys ['schema', 'architecture', 'initialization', 'loader_scale', 'tracks', 'head_arithmetic', 'head_refinement', 'clinical_spectral_refinement', 'head_estimation', 'clinical_asymmetry_refinement', 'alpha_rhythm_adapter', 'clinical_envelope_refinement', 'independent_adapter_merge', 'frequency_montage_refinement', 'private_track_selection', 'clinical_sampling_refinement', 'temporal_statistics_readout', 'temporal_evidence_readout', 'fourier_basis_readout', 'shared_tangent_readout', 'shared_context_correction', 'shared_wave_coactivation', 'fixed_common_coactivation_readouts', 'shared_ordinal_context', 'shared_complex_coherence', 'shared_cross_frequency', 'inherited_private_readout_refresh', 'shared_student_residual', 'private_head_refresh', 'shared_student_extension_residual', 'fixed_common_embedding_readouts', 'shared_center_context_residual', 'private_input_head_refresh', 'shared_short_context_residual', 'shared_dual_context_residual', 'shared_geometry_residual', 'fixed_common_geometry_input_readouts', 'shared_emotion_residual', 'shared_refinement_residual', 'fixed_common_refinement_input_readouts', 'shared_spatial_residual', 'fixed_common_spatial_input_readouts', 'shared_conditional_residual', 'continued_shared_model', 'fixed_common_private_selection', 'frozen_confidence_modulation', 'private_confidence_gate_selection', 'shared_multitaper_refinement', 'shared_weighted_pattern_refinement', 'shared_spectral_filter_refinement', 'shared_expert_routing_refinement', 'shared_additive_hinge_refinement', 'shared_dual_readout_refinement', 'shared_temporal_basis_refinement', 'shared_temporal_scale_refinement', 'shared_activation_groups_refinement']\nmodel_card # Shared EEG decoder\n\nThis package contains one coupled backbone used by all five tracks, with private input adapters and classifiers. Every trainable common component was trained with all five training splits. It is a single model; inference performs no parameter updates or dataset-level fitting.\n\nThe common backbone combines waveform convolutions, an audited pretrained BIOT feature path, covariance and log-correlation encoders, and shared feature corrections. The waveform coactivation extension encodes 64 within-window log variances and 2,016 correlations between common waveform channels. A matched experimental control removes the correlation inputs. `config.json` identifies the packaged variant and its five fixed correction gains. All original backbone parameters are fixed during this extension's joint training.\n\nWeights originate only from the supplied training data and audited initialization checkpoints. Training details, parent provenance, raw/cache checks, shared-gradient checks and the five separate validation metrics are recorded in `training.json`. Validation selects checkpoints and fixed gains; it does not fit normalization or update parameters. Reported validation results belong to selected checkpoints, not to private test evaluation or five-seed means.\n\nRun `bash infer.sh INPUT_DIR OUTPUT_DIR`. The input manifest specifies a track and opaque sample IDs, shard paths and indices. Signals are in microvolts and are scaled by 1/100. The package writes one probability vector per input ID to `OUTPUT_DIR/predictions.jsonl`. It needs only the packaged files and the contract's installed Python dependencies, works after relocation, and does not need labels, subject IDs, training caches or network access.\n\nFACED and TUEV use window balanced accuracy. AD65 uses mean window probabilities per patient before balanced accuracy. OpenBMI averages within-subject balanced accuracy. Longitudinal averages within-session balanced accuracy within each subject, then over subjects. These five metrics remain separate.\n\nThis checkpoint adds fixed within-window ordinal pattern probabilities, permutation entropy and statistical complexity at five delays. Training-only normalization and five input projections feed one common correction MLP trained by all five tracks. The common correction enters the existing covariance and fusion representations; fixed per-track gains select its strength. All earlier model tensors remain unchanged.\n\nFixed real and imaginary spectral coherence between the inherited 24 spatial filters is normalized using training windows only and encoded by one new common network. Five private linear heads add class evidence. All five training splits update the new common encoder; all earlier model tensors remain unchanged.\n\nFixed per-window relative band powers, envelope variability, envelope correlations and phase-amplitude coupling feed training-normalized private input projections and one new shared encoder. Five linear heads add class evidence. All five training splits update the new common encoder; all prior model tensors remain unchanged. AD65 updates use all windows from six class-balanced training patients; objective: mean-probability.\n\nThe inherited OpenBMI phase-classifier projection was refreshed from a separately validated private-readout fit. Every common tensor and input adapter of this jointly trained model is unchanged. Exact ancestor checks confirm that all common tensors used by this inherited readout are identical; the new cross-frequency correction remains disabled for OpenBMI. No shared checkpoints or predictions are ensembled.\n\nA common CBraMod feature encoder, itself jointly trained on all five training splits, supplies its shared summary and tokens pooled into four ordered time bins. Its classifiers are discarded. A new common feature MLP and five zero-initialized private linear projections learn residual class evidence jointly on all five training splits. Training may randomly remove the earlier decoder logits for half of training groups, using one mask per AD patient and one per other window; labels and teacher targets remain unchanged. Validation and inference always retain the complete earlier decoder. The same new class projection also receives an auxiliary standalone classification loss when configured, with the same patient-pooled AD objective; this adds no inference module. The complete earlier decoder and feature extractor remain tensor-identical; selecting zero residual gain preserves its predictions exactly. The summary-only control masks the 8192 ordered features after training-fitted per-feature normalization. One feature backbone and one classifier per track run at inference, with no prediction ensemble or external runtime cache.\n\nThe five outer private student-feature class projections are refined on all five training splits while every common/input/prior-head tensor remains exactly fixed. AD uses the exact patient-mean probability objective. Private checkpoints may be selected independently only because the common representation is identical; all five metrics are evaluated for every exported package.\n\nThe longitudinal private outer projection is selected from another training-only readout fit using exactly the same common/input/prior-head tensors. All other private heads are retained. Exact equality of every common tensor and executable runtime is audited; this package has one common checkpoint and one head per track.\n\nThe complete stronger parent is retained, \nclosure_sha256 3f70e7cb494d2d93fa03460c2dea5de85d2d47c141948aba1db7a690e4a431db\nscores {'faced': 0.5382716049382716, 'tuev': 0.7073115703982028, 'ad65': 0.8380952380952381, 'openbmi': 0.823409090909091, 'longitudinal': 0.855189948192487}\nsource /workspace/research/experiments543/all_full/epoch-008\nrecorded_pass True\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_8","type":"agent_message","text":"The existing records confirm experiment 543 passed replay, relocation, and all five inference checks. I’m republishing that exact package atomically and checking its files against the recorded hashes.\n"}}
+{"type":"item.started","item":{"id":"item_9","type":"command_execution","command":"/bin/sh -lc \"mkdir -p /workspace/finalization\ncat > /workspace/finalization/finalize_submission.py <<'PY'\nimport ast\nimport ctypes\nimport datetime\nimport hashlib\nimport json\nimport os\nfrom pathlib import Path\nimport shutil\nimport subprocess\n\nroot = Path('/workspace/finalization')\nclosure_path = Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nclosure_bytes = closure_path.read_bytes()\nclosure_hash = hashlib.sha256(closure_bytes).hexdigest()\nassert closure_hash == '3f70e7cb494d2d93fa03460c2dea5de85d2d47c141948aba1db7a690e4a431db'\nclosure = json.loads(closure_bytes)\nexpected = closure['all_package_file_sha256']\nassert len(expected) == 47\nsource = Path(closure['source'])\nassert source == Path('/workspace/research/experiments543/all_full/epoch-008')\nassert closure['direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'] is True\nstate = json.loads(Path('/workspace/research/published_state.json').read_text())\nassert state['source'] == str(source)\nassert state['weights_sha256'] == closure['weights_sha256']\nassert state['verification_status'] == 'complete'\nsubmission = Path('/workspace/submission')\nassert submission.is_dir() and not submission.is_symlink()\nstamp = datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%dT%H%M%SZ')\nstage = root / ('package543-' + stamp)\nassert not stage.exists()\n\nlibc = ctypes.CDLL(None, use_errno=True)\nexchange = libc.renameat2\nexchange.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]\nexchange.restype = ctypes.c_int\nassert root.stat().st_dev == submission.parent.stat().st_dev\n\ndef audit_files(folder):\n    actual = {}\n    for path in sorted(folder.rglob('*')):\n        assert not path.is_symlink(), str(path)\n        if path.is_dir():\n            continue\n        assert path.is_file(), str(path)\n        name = path.relative_to(folder).as_posix()\n        h = hashlib.sha256()\n        with path.open('rb') as stream:\n            for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b''):\n                h.update(chunk)\n        actual[name] = h.hexdigest()\n    assert set(actual) == set(expected), (set(actual) - set(expected), set(expected) - set(actual))\n    assert actual == expected, [name for name in actual if actual[name] \"'!= expected[name]]\n    return actual\n\nshutil.copytree(source, stage, symlinks=True)\naudit_files(stage)\nfor path in stage.glob('\"'*.py'):\n    ast.parse(path.read_text(), filename=path.name)\nfor path in stage.glob('*.json'):\n    json.loads(path.read_text())\nsubprocess.run(['bash', '-n', str(stage / 'infer.sh')], check=True)\nassert (stage / 'weights.pt').stat().st_size > 0\nassert expected['weights.pt'] == 'fb1405db77c975a547acc95ca50fd8113aa42134a9b52b167843e4fa442ee61e'\nfor path in stage.rglob('*'):\n    if path.is_file():\n        assert path.stat().st_mode & 0o004, 'File must be readable by inference user: ' + str(path)\nassert stage.stat().st_mode & 0o005 == 0o005\nprint('Staged package matches all 47 recorded file hashes; static syntax and permissions pass.', flush=True)\nif exchange(-100, os.fsencode(stage), -100, os.fsencode(submission), 2) \"'!= 0:\n    error = ctypes.get_errno()\n    raise OSError(error, os.strerror(error))\ninstalled = audit_files(submission)\nreceipt = {\n    '\"'completed_at': datetime.datetime.now(datetime.timezone.utc).isoformat(),\n    'submission': str(submission),\n    'selected_existing_source': str(source),\n    'weights_sha256': closure['weights_sha256'],\n    'existing_proof_closure': str(closure_path),\n    'existing_proof_closure_sha256': closure_hash,\n    'selection_validation_scores_from_existing_records': closure['installed_scores'],\n    'atomic_publication': 'renameat2 RENAME_EXCHANGE',\n    'all_47_installed_package_hashes_match_existing_proof': True,\n    'all_package_file_sha256': installed,\n    'finalization_checks': ['file inventory and no symlinks', 'SHA256 hashes', 'Python AST syntax', 'JSON syntax', 'bash -n syntax', 'unprivileged read permissions'],\n    'new_training_inference_evaluation_or_experiments': False,\n    'previous_submission_backup': str(stage),\n}\nreceipt_path = root / 'submission-finalization.json'\nreceipt_path.write_text(json.dumps(receipt, indent=2) + '\\\\n')\nprint('Published /workspace/submission atomically; all 47 installed hashes match.')\nprint('Finalization receipt: ' + str(receipt_path))\nprint('Weights SHA256: ' + closure['weights_sha256'])\nPY\npython /workspace/finalization/finalize_submission.py\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_9","type":"command_execution","command":"/bin/sh -lc \"mkdir -p /workspace/finalization\ncat > /workspace/finalization/finalize_submission.py <<'PY'\nimport ast\nimport ctypes\nimport datetime\nimport hashlib\nimport json\nimport os\nfrom pathlib import Path\nimport shutil\nimport subprocess\n\nroot = Path('/workspace/finalization')\nclosure_path = Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nclosure_bytes = closure_path.read_bytes()\nclosure_hash = hashlib.sha256(closure_bytes).hexdigest()\nassert closure_hash == '3f70e7cb494d2d93fa03460c2dea5de85d2d47c141948aba1db7a690e4a431db'\nclosure = json.loads(closure_bytes)\nexpected = closure['all_package_file_sha256']\nassert len(expected) == 47\nsource = Path(closure['source'])\nassert source == Path('/workspace/research/experiments543/all_full/epoch-008')\nassert closure['direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'] is True\nstate = json.loads(Path('/workspace/research/published_state.json').read_text())\nassert state['source'] == str(source)\nassert state['weights_sha256'] == closure['weights_sha256']\nassert state['verification_status'] == 'complete'\nsubmission = Path('/workspace/submission')\nassert submission.is_dir() and not submission.is_symlink()\nstamp = datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%dT%H%M%SZ')\nstage = root / ('package543-' + stamp)\nassert not stage.exists()\n\nlibc = ctypes.CDLL(None, use_errno=True)\nexchange = libc.renameat2\nexchange.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]\nexchange.restype = ctypes.c_int\nassert root.stat().st_dev == submission.parent.stat().st_dev\n\ndef audit_files(folder):\n    actual = {}\n    for path in sorted(folder.rglob('*')):\n        assert not path.is_symlink(), str(path)\n        if path.is_dir():\n            continue\n        assert path.is_file(), str(path)\n        name = path.relative_to(folder).as_posix()\n        h = hashlib.sha256()\n        with path.open('rb') as stream:\n            for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b''):\n                h.update(chunk)\n        actual[name] = h.hexdigest()\n    assert set(actual) == set(expected), (set(actual) - set(expected), set(expected) - set(actual))\n    assert actual == expected, [name for name in actual if actual[name] \"'!= expected[name]]\n    return actual\n\nshutil.copytree(source, stage, symlinks=True)\naudit_files(stage)\nfor path in stage.glob('\"'*.py'):\n    ast.parse(path.read_text(), filename=path.name)\nfor path in stage.glob('*.json'):\n    json.loads(path.read_text())\nsubprocess.run(['bash', '-n', str(stage / 'infer.sh')], check=True)\nassert (stage / 'weights.pt').stat().st_size > 0\nassert expected['weights.pt'] == 'fb1405db77c975a547acc95ca50fd8113aa42134a9b52b167843e4fa442ee61e'\nfor path in stage.rglob('*'):\n    if path.is_file():\n        assert path.stat().st_mode & 0o004, 'File must be readable by inference user: ' + str(path)\nassert stage.stat().st_mode & 0o005 == 0o005\nprint('Staged package matches all 47 recorded file hashes; static syntax and permissions pass.', flush=True)\nif exchange(-100, os.fsencode(stage), -100, os.fsencode(submission), 2) \"'!= 0:\n    error = ctypes.get_errno()\n    raise OSError(error, os.strerror(error))\ninstalled = audit_files(submission)\nreceipt = {\n    '\"'completed_at': datetime.datetime.now(datetime.timezone.utc).isoformat(),\n    'submission': str(submission),\n    'selected_existing_source': str(source),\n    'weights_sha256': closure['weights_sha256'],\n    'existing_proof_closure': str(closure_path),\n    'existing_proof_closure_sha256': closure_hash,\n    'selection_validation_scores_from_existing_records': closure['installed_scores'],\n    'atomic_publication': 'renameat2 RENAME_EXCHANGE',\n    'all_47_installed_package_hashes_match_existing_proof': True,\n    'all_package_file_sha256': installed,\n    'finalization_checks': ['file inventory and no symlinks', 'SHA256 hashes', 'Python AST syntax', 'JSON syntax', 'bash -n syntax', 'unprivileged read permissions'],\n    'new_training_inference_evaluation_or_experiments': False,\n    'previous_submission_backup': str(stage),\n}\nreceipt_path = root / 'submission-finalization.json'\nreceipt_path.write_text(json.dumps(receipt, indent=2) + '\\\\n')\nprint('Published /workspace/submission atomically; all 47 installed hashes match.')\nprint('Finalization receipt: ' + str(receipt_path))\nprint('Weights SHA256: ' + closure['weights_sha256'])\nPY\npython /workspace/finalization/finalize_submission.py\"","aggregated_output":"Staged package matches all 47 recorded file hashes; static syntax and permissions pass.\nTraceback (most recent call last):\n  File \"/workspace/finalization/finalize_submission.py\", line 71, in <module>\n    raise OSError(error, os.strerror(error))\nOSError: [Errno 18] Invalid cross-device link\n","exit_code":1,"status":"failed"}}
+{"type":"item.started","item":{"id":"item_10","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/baseline/braindecode/publish.py'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_10","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/baseline/braindecode/publish.py'","aggregated_output":"#!/usr/bin/env python3\n\"\"\"Publish a package directory to /workspace/submission atomically.\n\n    python /workspace/baseline/braindecode/publish.py SRC [--check]\n\nThe verifier may read /workspace/submission at any moment, so the package must never be half\nwritten. This copies SRC (a version symlink written by train_shared.py is resolved) into a\nstaging directory next to the target, optionally runs its infer.sh on a slice of every\nvalidation split and checks the predictions with the verifier's reader, then swaps it in.\n\"\"\"\nimport argparse\nimport errno\nimport json\nimport os\nimport shutil\nimport subprocess\nimport sys\nimport tempfile\nfrom pathlib import Path\n\nimport numpy as np\n\nsys.path.insert(0, str(Path(__file__).resolve().parents[2] / 'evaluation'))\nfrom bci_score import CLASSES, read_predictions  # noqa: E402\n\nEXCLUDE = shutil.ignore_patterns('__pycache__', '*.pyc', 'resume*', 'optimizer*.pt')\n\n\ndef swap_into(staged, final):\n    old = final.with_name(f'.{final.name}.old-{os.getpid()}')\n    if final.exists() or final.is_symlink():\n        try:\n            os.replace(final, old)\n        except OSError as error:\n            # A directory from a lower image layer cannot be renamed on overlayfs (EXDEV).\n            if error.errno != errno.EXDEV:\n                raise\n            shutil.copytree(final, old, symlinks=True)\n            shutil.rmtree(final)\n    os.replace(staged, final)\n    if old.is_symlink() or old.is_file():\n        old.unlink()\n    else:\n        shutil.rmtree(old, ignore_errors=True)\n\n\ndef check(staged, data, samples):\n    for track, classes in CLASSES.items():\n        split = data / track / 'val'\n        manifest = json.loads((split / 'manifest.json').read_text())\n        rows = manifest['samples'][:samples]\n        with tempfile.TemporaryDirectory() as work:\n            inp, out = Path(work) / 'input', Path(work) / 'output'\n            inp.mkdir()\n            out.mkdir()\n            # One fresh shard with the sampled windows, as the verifier stages copied inputs.\n            arrays = {}\n            for r in rows:\n                if r['path'] not in arrays:\n                    arrays[r['path']] = np.load(split / r['path'], mmap_mode='r')\n            np.save(inp / 'shard-000000.npy', np.stack([arrays[r['path']][r['index']] for r in rows]))\n            public = [{'id': r['id'], 'path': 'shard-000000.npy', 'index': i} for i, r in enumerate(rows)]\n            (inp / 'manifest.json').write_text(json.dumps({**manifest, 'samples': public}))\n            subprocess.run(['bash', str(staged / 'infer.sh'), str(inp), str(out)], check=True)\n            read_predictions(out / 'predictions.jsonl', rows, classes)\n        print(f'{track}: {len(rows)} validation predictions follow contract.md', flush=True)\n\n\ndef main():\n    parser = argparse.ArgumentParser(description=__doc__.split('\\n\\n')[0])\n    parser.add_argument('source', type=Path)\n    parser.add_argument('--output', type=Path, default=Path('/workspace/submission'))\n    parser.add_argument('--data', type=Path, default=Path('/workspace/data'))\n    parser.add_argument('--check', action='store_true',\n                        help='run infer.sh on a slice of every validation split before publishing')\n    parser.add_argument('--check-samples', type=int, default=256)\n    args = parser.parse_args()\n    source, final = args.source.resolve(), args.output.absolute()\n    if not (source / 'infer.sh').is_file():\n        sys.exit(f'{source} has no infer.sh')\n    if any(p.is_symlink() for p in source.rglob('*')):\n        sys.exit('package contents must not contain symlinks (contract.md)')\n    staged = Path(tempfile.mkdtemp(prefix=f'.{final.name}.staging-', dir=final.parent))\n    os.chmod(staged, 0o755)\n    try:\n        shutil.copytree(source, staged, ignore=EXCLUDE, dirs_exist_ok=True)\n        if args.check:\n            check(staged, args.data, args.check_samples)\n        swap_into(staged, final)\n    except BaseException:\n        shutil.rmtree(staged, ignore_errors=True)\n        raise\n    print(f'published {source} -> {final}')\n\n\nif __name__ == '__main__':\n    main()\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_11","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nimport os\nfor name in ['/workspace','/workspace/submission','/workspace/finalization']:\n p=Path(name); print(name,'real',p.resolve(),'device',p.stat().st_dev,'mount',os.path.ismount(p))\nprint('stages',list(Path('/workspace/finalization').glob('package543-*')))\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_11","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nimport os\nfor name in ['/workspace','/workspace/submission','/workspace/finalization']:\n p=Path(name); print(name,'real',p.resolve(),'device',p.stat().st_dev,'mount',os.path.ismount(p))\nprint('stages',list(Path('/workspace/finalization').glob('package543-*')))\nPY\"","aggregated_output":"/workspace real /workspace device 76 mount False\n/workspace/submission real /workspace/submission device 76 mount False\n/workspace/finalization real /workspace/finalization device 76 mount False\nstages [PosixPath('/workspace/finalization/package543-20261102T214013Z')]\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_12","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport ast, datetime, hashlib, json, os, subprocess\nfrom pathlib import Path\nroot=Path('/workspace/finalization')\nproof=Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nproof_hash=hashlib.sha256(proof.read_bytes()).hexdigest()\nassert proof_hash=='3f70e7cb494d2d93fa03460c2dea5de85d2d47c141948aba1db7a690e4a431db'\nclosure=json.loads(proof.read_text())\nexpected=closure['all_package_file_sha256']\npackage=Path('/workspace/submission')\nassert package.is_dir() and not package.is_symlink()\nactual={}\nfor path in sorted(package.rglob('*')):\n assert not path.is_symlink(), str(path)\n if path.is_dir():\n  assert path.stat().st_mode & 0o005 == 0o005\n  continue\n assert path.is_file() and path.stat().st_mode & 0o004\n h=hashlib.sha256()\n with path.open('rb') as stream:\n  for chunk in iter(lambda: stream.read(8*1024*1024),b''): h.update(chunk)\n actual[path.relative_to(package).as_posix()]=h.hexdigest()\nassert actual==expected\nassert len(actual)==47\nassert package.stat().st_mode & 0o005 == 0o005\nfor path in package.glob('*.py'): ast.parse(path.read_text(),filename=path.name)\nfor path in package.glob('*.json'): json.loads(path.read_text())\nsubprocess.run(['bash','-n',str(package/'infer.sh')],check=True)\nreceipt={\n 'completed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),\n 'submission':str(package),\n 'selected_existing_source':closure['source'],\n 'weights_sha256':closure['weights_sha256'],\n 'existing_proof_closure':str(proof),\n 'existing_proof_closure_sha256':proof_hash,\n 'publication_action':'Retained the already published complete package, byte-identical to the selected proof-closed source.',\n 'existing_atomic_publication_and_all_checks_recorded_before_finalization':closure['direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'],\n 'staging_note':'A fresh copy matched all 47 archived hashes. Atomic exchange returned EXDEV on the image-layer submission directory, leaving the already published submission unchanged. Static verification confirmed the installed package is exactly the selected candidate.',\n 'all_47_installed_package_hashes_match_existing_proof':True,\n 'all_package_file_sha256':actual,\n 'selection_validation_scores_from_existing_records':closure['installed_scores'],\n 'finalization_checks':['file inventory','no symlinks','SHA256 hashes','Python AST syntax','JSON syntax','bash -n syntax','unprivileged read permissions'],\n 'new_training_inference_evaluation_or_experiments':False,\n}\np=root/'submission-finalization.json'\np.write_text(json.dumps(receipt,indent=2)+'\\\\n')\nprint('FINALIZED /workspace/submission: all 47 package files match the existing verified experiment 543 package.')\nprint('Weights SHA256:',closure['weights_sha256'])\nprint('Receipt:',p)\nprint('No training, inference, evaluation, simulation, or experiment was run during finalization.')\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_12","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport ast, datetime, hashlib, json, os, subprocess\nfrom pathlib import Path\nroot=Path('/workspace/finalization')\nproof=Path('/workspace/research/publication-fb1405db77c9-installed-closure.json')\nproof_hash=hashlib.sha256(proof.read_bytes()).hexdigest()\nassert proof_hash=='3f70e7cb494d2d93fa03460c2dea5de85d2d47c141948aba1db7a690e4a431db'\nclosure=json.loads(proof.read_text())\nexpected=closure['all_package_file_sha256']\npackage=Path('/workspace/submission')\nassert package.is_dir() and not package.is_symlink()\nactual={}\nfor path in sorted(package.rglob('*')):\n assert not path.is_symlink(), str(path)\n if path.is_dir():\n  assert path.stat().st_mode & 0o005 == 0o005\n  continue\n assert path.is_file() and path.stat().st_mode & 0o004\n h=hashlib.sha256()\n with path.open('rb') as stream:\n  for chunk in iter(lambda: stream.read(8*1024*1024),b''): h.update(chunk)\n actual[path.relative_to(package).as_posix()]=h.hexdigest()\nassert actual==expected\nassert len(actual)==47\nassert package.stat().st_mode & 0o005 == 0o005\nfor path in package.glob('*.py'): ast.parse(path.read_text(),filename=path.name)\nfor path in package.glob('*.json'): json.loads(path.read_text())\nsubprocess.run(['bash','-n',str(package/'infer.sh')],check=True)\nreceipt={\n 'completed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),\n 'submission':str(package),\n 'selected_existing_source':closure['source'],\n 'weights_sha256':closure['weights_sha256'],\n 'existing_proof_closure':str(proof),\n 'existing_proof_closure_sha256':proof_hash,\n 'publication_action':'Retained the already published complete package, byte-identical to the selected proof-closed source.',\n 'existing_atomic_publication_and_all_checks_recorded_before_finalization':closure['direct_full5_readonly5_entire_stage_replay_and_contract_completed_before_publication'],\n 'staging_note':'A fresh copy matched all 47 archived hashes. Atomic exchange returned EXDEV on the image-layer submission directory, leaving the already published submission unchanged. Static verification confirmed the installed package is exactly the selected candidate.',\n 'all_47_installed_package_hashes_match_existing_proof':True,\n 'all_package_file_sha256':actual,\n 'selection_validation_scores_from_existing_records':closure['installed_scores'],\n 'finalization_checks':['file inventory','no symlinks','SHA256 hashes','Python AST syntax','JSON syntax','bash -n syntax','unprivileged read permissions'],\n 'new_training_inference_evaluation_or_experiments':False,\n}\np=root/'submission-finalization.json'\np.write_text(json.dumps(receipt,indent=2)+'\\\\n')\nprint('FINALIZED /workspace/submission: all 47 package files match the existing verified experiment 543 package.')\nprint('Weights SHA256:',closure['weights_sha256'])\nprint('Receipt:',p)\nprint('No training, inference, evaluation, simulation, or experiment was run during finalization.')\nPY\"","aggregated_output":"FINALIZED /workspace/submission: all 47 package files match the existing verified experiment 543 package.\nWeights SHA256: fb1405db77c975a547acc95ca50fd8113aa42134a9b52b167843e4fa442ee61e\nReceipt: /workspace/finalization/submission-finalization.json\nNo training, inference, evaluation, simulation, or experiment was run during finalization.\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_13","type":"agent_message","text":"Finalized the already-published experiment 543 package at `/workspace/submission`, the strongest verified candidate.\n\nAll 47 files match the recorded hashes. No new training, inference, or experiments were run. Research is stopped."}}
+{"type":"turn.completed","usage":{"input_tokens":1039456515,"cached_input_tokens":1015327241,"cache_write_input_tokens":23391964,"output_tokens":8009513,"reasoning_output_tokens":3699926}}