{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.12.13"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceType":"competition","sourceId":154281},{"sourceType":"datasetVersion","sourceId":19120128},{"sourceType":"datasetVersion","sourceId":19122845},{"sourceType":"datasetVersion","sourceId":19134209},{"sourceType":"datasetVersion","sourceId":18956429},{"sourceType":"datasetVersion","sourceId":19395055},{"sourceType":"datasetVersion","sourceId":18229736},{"sourceType":"datasetVersion","sourceId":19395706},{"sourceType":"datasetVersion","sourceId":19554898},{"sourceType":"datasetVersion","sourceId":18842180},{"sourceType":"datasetVersion","sourceId":18839182},{"sourceType":"datasetVersion","sourceId":18673450},{"sourceType":"datasetVersion","sourceId":18879001},{"sourceType":"datasetVersion","sourceId":18716507},{"sourceType":"kernelVersion","sourceId":342671664},{"sourceType":"kernelVersion","sourceId":342849430},{"sourceType":"modelInstanceVersion","sourceId":4533}],"dockerImageVersionId":31430,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false},"rsna_revision":{"chain":["v8","codex-v559","v559b","v559c","v559d"],"code_cells_changed_vs_v8":[0,2,3,6,8,12,13,14,15,16,18,19,20,21,22],"code_cells_identical_to_v8":[1,4,5,7,9,10,11,17],"codex_v559_record":{"hidden_failure_cause_proven":false,"parent_sha256":"25517eeca8e75c7267a25df88e9a44a20429e0e8728be1013a697b8a3ae93930","scope":"metadata absence, protocol flag parsing, temporary cache placement, local phase receipts","t4_end_to_end_executed_here":false,"version":"v559-targeted-failure-fixes"},"hidden_failure_cause_proven":false,"scope":"data-driven aborts relaxed to flagged degradations; fp16 non-finite shield on every autocast site; asset/contract/checkpoint aborts unchanged","t4_end_to_end_executed_here":false,"v559_notebook_sha256":"20e00b27a5a0938a932b31727becf371fb169f286944f387f1cc0bae9d518c6b","v559b_notebook_sha256":"3b1843b29cc30a6f1c1ab474de5d0a68d4a359f05d067fda4204f02042319b08","v559b_patches":2,"v559c_notebook_sha256":"16f9348f4e680656b56b9ea1622c806eca3cd0c49518c6bfeaefce9f46810f2d","v559c_patches":34,"v559d_notebook_sha256":"9e16f34eba8d90f9ad2675ad26a01717d348afe43659790b37354d37fb13f09f","v559d_patches":1,"v8_notebook_sha256":"31727d161a26d001a9ab8ba391040c2649957622c6098ec4eca54d5416b11203","version":"v9-v559d"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"
\n
\n
\n RSNA 2026 Frontier Experimental SOTA Engine\n

🩻 [0.943+ Target] RSNA Knee: Speedy Raptors, CoAtNet D4 & Evidential Rank Consensus

\n
\n
\n 🚀 Target Metric: 0.943+ Macro ROC-AUC\n
\n
\n

\n Advanced experimental inference pipeline combining the 0.942 Speedy Raptors & CoAtNet D4 2xT4 Engine with principles inspired by recent arXiv medical imaging research (MeniOmni 2026 & Evidential Rank Fusion). Integrates DINOsaur V5 Calibration-Robust Raptor Consensus, specialized bone contusion weighting, and clinical sweet-spot synovitis calibration.\n

\n
\n
\n
Consensus Fusion
\n
Dual Probability & Rank Space (α=0.35)
\n
\n
\n
Clinical Prior Synergy
\n
Effusion → Synovitis (γ=0.20)
\n
\n
\n
Pathology Weight Tuning
\n
Contusion = 0.70 CoAtNet Specialization
\n
\n
\n
Multi-GPU Engine
\n
2x Tesla T4 Parallel Replicas (< 4h)
\n
\n
\n
\n Attribution: Mattia Angeli · Roman Tamrazov (DINOsaur V5) · Jiwei Liu · Pilkwang · Sofia Anjenje · Antoine G. · prvsiyan · Marwan Mahmoud · renta0426\n
\n
\n","metadata":{}},{"cell_type":"code","source":"import os\nfor _thread_env in ('OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS'):\n os.environ.setdefault(_thread_env, '4')\nos.environ.setdefault('CUDNN_CONV_WSCAP_DBG', '1024')\n\ndef _d4_check_runtime(rt, artifact_root):\n import hashlib\n import json\n from pathlib import Path\n import torch\n root = Path(artifact_root)\n manifest_path = root / 'coatnet_pairfilm_manifest.json'\n digest = hashlib.sha256(manifest_path.read_bytes()).hexdigest()\n if digest != '7ada0605bca6b0530569c6454e988ace479606a3328ed591d090e5764fea661d':\n raise RuntimeError('D4 reference manifest identity changed')\n expected = json.loads(manifest_path.read_text())\n manifest, paths = rt.validate_artifact_root(root, verify_hashes=True)\n if manifest != expected or len(paths) != 1 or rt.N_MODELS != 1:\n raise RuntimeError('D4 must load exactly the reference SWA model')\n if Path(paths[0]).name != 'coatnet_d4_parent_rank8_swa2.pt':\n raise RuntimeError('D4 must use its reference rank-8 parent checkpoint')\n if manifest['slice_depth']['adapter_sha256'] != 'b7c48b19997bc7ecb7e997f8dcf491ec5701ff917d1dac4b369eb85ac97ae89a':\n raise RuntimeError('D4 reference adapter identity changed')\n if rt.GPU_BATCH_STUDIES != 2 or rt.BACKBONE_MICRO_IMAGES != 8:\n raise RuntimeError('D4 reference batching changed')\n if rt.CUDNN_BENCHMARK is not False:\n raise RuntimeError('D4 reference convolution policy changed')\n if rt.base.cv2.__version__ != '4.12.0' or rt.parent.timm.__version__ != '1.0.22':\n raise RuntimeError('D4 reference dependency versions changed')\n if torch.cuda.device_count() != 2:\n raise RuntimeError('D4 requires exactly two T4 GPUs')\n names = [torch.cuda.get_device_name(i) for i in range(2)]\n if not all(('T4' in name for name in names)):\n raise RuntimeError(f'D4 reference device mismatch: {names}')\n return (manifest, paths)\n\ndef _d4_check_outputs(rt, manifest, receipt, output, competition):\n import hashlib\n from pathlib import Path\n import numpy as np\n import pandas as pd\n\n def need(condition, message):\n if not condition:\n raise RuntimeError('D4 release check: ' + message)\n need(receipt['status'] == rt.SUBMISSION_STATUS, 'unsuccessful status')\n expected_fields = {'models': 1, 'fallback_studies': 0, 'dicom_preparations_per_study': 1, 'model_passes_per_study': 1, 'rank_after_probability_average': True, 'canonical_sagittal': True, 'common_physical_triplet_warp': False, 'resolution': 384, 'slice_depth_arm': 'd4_zones', 'slice_depth_state_elements': 3255, 'slice_depth_parent_checkpoint_sha256': '5de38e333e3184d7b52fb068183f0cc198d6cbabb6ffbe36b26338622e82d297', 'fsx_attention_heads': 2, 'fsx_attention_width': 128, 'fsx_serving_delta_cap': 0.3, 'fsx_training_delta_cap': 0.5, 'head': 'rank8_swa2_plus_d4_three_zone_expanded_fsx', 'slice_depth_swa_member_epochs': [11, 9, 5], 'slice_depth_checkpoint_sha256': manifest['slice_depth']['adapter_sha256']}\n for key, value in expected_fields.items():\n need(receipt[key] == value, key)\n need(1 <= int(receipt['maximum_eval_windows']) <= 94, 'window limit')\n checkpoints = receipt['checkpoints']\n need(len(checkpoints) == 1, 'parent checkpoint count')\n need(checkpoints[0]['sha256'] == '5de38e333e3184d7b52fb068183f0cc198d6cbabb6ffbe36b26338622e82d297', 'parent checkpoint hash')\n need(checkpoints[0]['member_epochs'] == [15, 16], 'parent SWA member epochs')\n need(receipt['slice_depth_checkpoint_sha256'] == 'b7c48b19997bc7ecb7e997f8dcf491ec5701ff917d1dac4b369eb85ac97ae89a', 'adapter checkpoint hash')\n processes = receipt['processes']\n need(len(processes) == 2 and all((int(p['returncode']) == 0 for p in processes)), 'worker process failure')\n shards = receipt['shards']\n need(len(shards) == 2, 'shard count')\n for s in shards:\n need(s['device'] == 'cuda', 'non-CUDA shard')\n need(int(s['fallback_studies']) == 0 and int(s['preparation_warnings']) == 0, 'failed study/preparation')\n need(int(s['models_resident']) == 1, 'resident model count')\n need(int(s['peak_reserved_bytes']) < int(15.5 * 1024 ** 3), 'reference memory gate')\n need(s['specialized_worker_loader_contract'] == manifest['worker_loader_contract'], 'specialized loader')\n output = Path(output)\n prediction_path = output.parent / rt.PREDICTIONS_NAME\n with np.load(prediction_path, allow_pickle=False) as payload:\n uids = payload['study_uids'].astype(str).tolist()\n raw = np.asarray(payload['raw_probabilities'], dtype=np.float32)\n mean = np.asarray(payload['probability_mean'], dtype=np.float32)\n ranked = np.asarray(payload['submission_percentile_rank'], dtype=np.float64)\n ids = pd.read_csv(Path(competition) / 'test.csv', dtype={'StudyInstanceUID': str}).StudyInstanceUID.tolist()\n need(len(ids) > 0 and len(ids) == len(set(ids)), 'test identity')\n need(uids == ids and int(receipt['studies']) == len(ids), 'prediction identity/count')\n need(raw.shape == (1, len(ids), 12), 'raw probability shape')\n need(np.isfinite(raw).all() and ((raw >= 0) & (raw <= 1)).all(), 'raw probabilities')\n need(np.array_equal(raw.astype(np.float64).mean(0).astype(np.float32), mean), 'probability mean')\n need(np.array_equal(rt.percentile_rank64(mean), ranked), 'global percentile ranks')\n frame = pd.read_csv(output, dtype={'StudyInstanceUID': str}, float_precision='round_trip')\n need(frame.columns.tolist() == ['StudyInstanceUID', *rt.base.LABELS], 'CSV labels')\n need(frame.StudyInstanceUID.tolist() == ids, 'CSV identity')\n need(np.array_equal(frame.iloc[:, 1:].to_numpy(np.float64), ranked), 'CSV numeric round trip')\n actual_hash = hashlib.sha256(output.read_bytes()).hexdigest()\n need(actual_hash == receipt['output_sha256'], 'CSV hash')\n receipt['reference_wrapper_checks'] = {'export_sha256': '7f8410fdf1b60cd3831d50f517bb25798a4e4a3404c59dc269193d5fe7cce729', 'validated_manifest_sha256': '7ada0605bca6b0530569c6454e988ace479606a3328ed591d090e5764fea661d', 'probability_mean_exact': True, 'ranks_exact': True, 'csv_roundtrip_exact': True, 'source_and_model_hashes_validated': True, 'input_identity_equals_original_grid': False}\n return receipt\n\ndef _run_required_child(command, environment, logfile):\n import os\n import signal\n import subprocess\n import time\n from pathlib import Path\n remaining = TIME_BUDGET - (time.time() - T0)\n if remaining <= 0:\n raise TimeoutError('No time remains for a required model branch')\n path = Path(logfile)\n path.parent.mkdir(parents=True, exist_ok=True)\n with path.open('w') as log_handle:\n process = subprocess.Popen(command, env=environment, stdout=log_handle, stderr=subprocess.STDOUT, start_new_session=True)\n try:\n returncode = process.wait(timeout=remaining)\n except BaseException:\n try:\n os.killpg(process.pid, signal.SIGTERM)\n except ProcessLookupError:\n pass\n try:\n process.wait(timeout=10)\n except subprocess.TimeoutExpired:\n try:\n os.killpg(process.pid, signal.SIGKILL)\n except ProcessLookupError:\n pass\n process.wait()\n raise\n if returncode != 0:\n with path.open('rb') as handle:\n handle.seek(max(0, path.stat().st_size - 5000))\n tail = handle.read().decode('utf-8', errors='replace')\n raise RuntimeError(f'Required model branch failed ({returncode}); {path}\\n{tail}')\n return returncode\nASSET_ROOTS = ['/kaggle/input/datasets/dreaddevelopment/raptor-knee-maxspan', '/kaggle/input/raptor-knee-maxspan', '/kaggle/input/datasets/dreaddevelopment/raptor-knee-native384', '/kaggle/input/raptor-knee-native384', '/kaggle/input/datasets/dreaddevelopment/raptor-knee-native384dense', '/kaggle/input/raptor-knee-native384dense', '/kaggle/input/datasets/mattiaangeli/knee-mri-fold-weights', '/kaggle/input/knee-mri-fold-weights', '/kaggle/input/datasets/mattiaangeli/opencv-python-headless-4120088-x86', '/kaggle/input/opencv-python-headless-4120088-x86', '/kaggle/input/datasets/marwanmath/resnet-50-radimagenet-marwan', '/kaggle/input/resnet-50-radimagenet-marwan', '/kaggle/input/datasets/mattiaangeli/rsna-knee-coat-resgated-ep10-top3', '/kaggle/input/rsna-knee-coat-resgated-ep10-top3', '/kaggle/input/datasets/antoinegg1/rsna-knee-e11-diverse-heads-v20', '/kaggle/input/rsna-knee-e11-diverse-heads-v20', '/kaggle/input/datasets/antoinegg1/rsna-knee-e9-radimagenet-heads-v15', '/kaggle/input/rsna-knee-e9-radimagenet-heads-v15', '/kaggle/input/datasets/pilkwang/rsna-knee-llm-labels', '/kaggle/input/rsna-knee-llm-labels', '/kaggle/input/datasets/prvsiyan/rsna-knee-v52-radimagenet-heads-20260812', '/kaggle/input/rsna-knee-v52-radimagenet-heads-20260812', '/kaggle/input/datasets/pilkwang/rsna-knee-weights', '/kaggle/input/rsna-knee-weights', '/kaggle/input/datasets/mattiaangeli/rsna-knee-coatnet-d4-depthzone-swa3-b2', '/kaggle/input/rsna-knee-coatnet-d4-depthzone-swa3-b2', '/kaggle/input/notebooks/sofiaanjenje/rsna-knee-e11-train', '/kaggle/input/rsna-knee-e11-train', '/kaggle/input/notebooks/sofiaanjenje/rsna-knee-e13-train', '/kaggle/input/rsna-knee-e13-train', '/kaggle/input/models/metaresearch/dinov2/pytorch/small/1', '/kaggle/input/dinov2/pytorch/small/1']\n\ndef _asset_walk():\n from pathlib import Path\n seen = set()\n for root in ASSET_ROOTS:\n root = Path(root).resolve()\n if not root.is_dir():\n continue\n level = [root]\n for _depth in range(6):\n following = []\n for directory in sorted(level):\n if str(directory) in seen:\n continue\n seen.add(str(directory))\n children = sorted(directory.iterdir())\n dirs = [p for p in children if p.is_dir() and p.name not in ('train_series', 'test_series', 'train_images', 'test_images')]\n files = [p.name for p in children if p.is_file()]\n yield (str(directory), [p.name for p in dirs], files)\n following.extend(dirs)\n level = following\n\ndef _asset_find_asset(name, digest=None):\n import fnmatch, hashlib\n from pathlib import Path\n hits = []\n for root, _, files in _asset_walk():\n for file in files:\n if fnmatch.fnmatchcase(file, name):\n p = Path(root) / file\n if digest:\n h = hashlib.sha256()\n with p.open('rb') as handle:\n for block in iter(lambda: handle.read(8 << 20), b''):\n h.update(block)\n if h.hexdigest() != digest:\n continue\n if p.resolve() not in [h.resolve() for h in hits]:\n hits.append(p)\n if len(hits) != 1:\n raise RuntimeError(f'expected one pinned asset {name}, got {hits}')\n return hits[0]\n\ndef _asset_half_rank_mix(top3, swa3):\n if top3.shape != swa3.shape or not top3.index.equals(swa3.index):\n raise ValueError('CoAt family alignment changed')\n if top3.isna().any().any() or swa3.isna().any().any():\n raise ValueError('missing CoAt family prediction')\n units = top3.rank(method='average') + swa3.rank(method='average')\n return units.rank(method='average', pct=True)\n\ndef _asset_write_coat_runtime(artifact, output, helper_source):\n from pathlib import Path\n import hashlib\n source = Path(artifact) / 'coatnet_resgated_ep10_top3_inference.py'\n text = source.read_text()\n if hashlib.sha256(source.read_bytes()).hexdigest() != 'b11e58f8d7cabe9e264ac70b01e811dc6a846aa01248ace1f0e6536d0d4094d9':\n raise RuntimeError('unexpected parent CoAt runtime')\n edits = {'if not 1 <= windows <= MAX_EVAL_WINDOWS:': 'if not 1 <= windows <= 94:', 'or int(counts.max()) > MAX_EVAL_WINDOWS:': 'or int(counts.max()) > 94:', '\"runtime_contract\": RUNTIME_CONTRACT,': '\"runtime_contract\": RUNTIME_CONTRACT, \"input_max_windows\": 94,', '\"eval_grid\": \"saved_training_gold_unique_center_slot_budgets\",': '\"eval_grid\": \"input_unique_native_centers_six_slot_v1\",'}\n for old, new in edits.items():\n if old not in text:\n raise RuntimeError('CoAt patch target missing: ' + old)\n text = text.replace(old, new)\n text = text.replace('\"gold58_rank_ensemble_auc\": manifest[\"selection\"]', '\"historical_parent_gold58_rank_ensemble_auc\": manifest[\"selection\"]')\n text = text.replace('\"t4_gold58_rank_ensemble_auc\": manifest[\"t4_numerical_portability\"]', '\"historical_parent_t4_gold58_rank_ensemble_auc\": manifest[\"t4_numerical_portability\"]')\n marker = 'if __name__ == \"__main__\":'\n if text.count(marker) != 1:\n raise RuntimeError('CoAt entrypoint changed')\n patch = helper_source + ('\\n_original_train_faithful_eval_specs = train_faithful_eval_specs\\n'\n 'def _tolerant_coat_specs(study):\\n try:\\n return _dense_coat_specs(study)\\n'\n ' except Exception as exc:\\n print(\"[dense-fallback] \" + str(getattr(study, \"study_uid\", \"?\")) + \": \" + type(exc).__name__ + \": \" + str(exc), flush=True)\\n'\n ' return _original_train_faithful_eval_specs(study)\\n'\n 'train_faithful_eval_specs = _tolerant_coat_specs\\nRUNTIME_CONTRACT = \"resgated_ep10_input_nativecenters_v1\"\\n')\n text = text.replace(marker, patch + '\\n' + marker)\n compile(text, str(output), 'exec')\n Path(output).write_text(text)\n return hashlib.sha256(text.encode()).hexdigest()\n\ndef _asset_patch_d4(rt, grid_source):\n import ast\n import hashlib\n import inspect\n import json\n import os\n import textwrap\n from pathlib import Path\n audited = rt.parent.audited\n original = audited.prepare_global96_bag\n original_shard = rt._PARENT_INFER_SHARD\n if getattr(original, '_input_patch_installed', False):\n raise RuntimeError('D4 input preparation was already patched')\n src = textwrap.dedent(inspect.getsource(original))\n tree = ast.parse(src)\n fn = next((n for n in tree.body if isinstance(n, ast.FunctionDef)), None)\n if fn is None or fn.name != 'prepare_global96_bag':\n raise RuntimeError('D4 preparation function identity changed')\n if 'study_uid' not in inspect.signature(original).parameters:\n raise RuntimeError('D4 preparation study-UID contract changed')\n candidates = [n for n in ast.walk(fn) if isinstance(n, ast.Assign) and any((isinstance(t, ast.Name) and t.id == 'specs' for t in n.targets)) and isinstance(n.value, ast.Call) and isinstance(n.value.func, ast.Attribute) and isinstance(n.value.func.value, ast.Name) and (n.value.func.value.id == 'global_stack') and (n.value.func.attr == 'sample_global_windows')]\n if len(candidates) != 1 or candidates[0] not in fn.body:\n raise RuntimeError('D4 expected one top-level Global96 specs constructor')\n call = candidates[0]\n keywords = {k.arg: k.value for k in call.value.keywords}\n if not (isinstance(keywords.get('count'), ast.Constant) and keywords['count'].value is None and isinstance(keywords.get('train'), ast.Constant) and (keywords['train'].value is False)):\n raise RuntimeError('D4 original evaluation must use count=None, train=False')\n exec(compile(grid_source, '', 'exec'), audited.__dict__)\n audit_dir = Path(os.environ['RSNA_D4_INPUT_AUDIT_DIR'])\n audit_dir.mkdir(parents=True, exist_ok=True)\n\n def record_input(study_uid, stack, audit):\n import numpy as np\n arrays = ('global_indices', 'nominal_slots', 'canonical_depths', 'nominal_steps', 'source_series_rows', 'source_slot_ids')\n digest = hashlib.sha256()\n for name in arrays:\n value = np.ascontiguousarray(getattr(stack, name))\n digest.update(name.encode())\n digest.update(str(value.dtype).encode())\n digest.update(str(value.shape).encode())\n digest.update(value.tobytes())\n record = {'study_uid': str(study_uid), 'pid': os.getpid(), 'positions': int(len(stack.global_indices)), 'windows_expected': int(len(stack.global_indices) - 2), 'slot_widths': list(map(int, stack.slot_widths)), 'stack_sidecars_sha256': digest.hexdigest(), 'slots': audit}\n with (audit_dir / f'input_{os.getpid()}.jsonl').open('a') as handle:\n handle.write(json.dumps(record, sort_keys=True, allow_nan=False) + '\\n')\n audited.__dict__['_record_input'] = record_input\n injection = ast.parse('try:\\n stack, input_audit = _dense_stack(stack, study.offsets, study.valid, study.source_depth)\\n'\n 'except Exception as _dense_exc:\\n print(\"[dense-fallback] \" + str(study_uid) + \": \" + type(_dense_exc).__name__ + \": \" + str(_dense_exc), flush=True)\\n'\n ' input_audit = [{\"fallback\": type(_dense_exc).__name__ + \": \" + str(_dense_exc)}]\\n'\n '_record_input(study_uid, stack, input_audit)\\n').body\n where = fn.body.index(call)\n fn.body[where:where] = injection\n ast.fix_missing_locations(tree)\n exec(compile(tree, '', 'exec'), audited.__dict__)\n patched = audited.prepare_global96_bag\n patched._input_patch_installed = True\n for module in (rt, rt.parent):\n if getattr(module, 'prepare_global96_bag', None) is original:\n module.prepare_global96_bag = patched\n if rt._PARENT_INFER_SHARD is not original_shard:\n raise RuntimeError('D4 parent shard must remain the official callable')\n files = {}\n for name, module in [('d4_runtime', rt), ('parent_runtime', rt.parent), ('audited_runtime', audited)]:\n path = Path(module.__file__)\n if path.is_file():\n files[name] = {'file': path.name, 'sha256': hashlib.sha256(path.read_bytes()).hexdigest()}\n receipt = {'contract': 'd4-original-runtime-input-preparation-only-v2', 'reference_script_version_id': 348764100, 'reference_export_available': True, 'original_prepare_source_sha256': hashlib.sha256(src.encode()).hexdigest(), 'patched_prepare_source_sha256': hashlib.sha256(ast.unparse(tree).encode()).hexdigest(), 'model_loader_modified': False, 'zone_head_modified': False, 'parent_infer_shard_replaced': False, 'grid_source_sha256': hashlib.sha256(grid_source.encode()).hexdigest(), 'artifact_source_files': files}\n (audit_dir / f'patch_{os.getpid()}.json').write_text(json.dumps(receipt, indent=2))\n return receipt\n\ndef _asset_run_d4(artifact, environment_dir, competition, output):\n import hashlib, inspect, json, os, sys\n from pathlib import Path\n import pandas as pd\n artifact, output = (Path(artifact), Path(output))\n manifest = artifact / 'coatnet_pairfilm_manifest.json'\n if hashlib.sha256(manifest.read_bytes()).hexdigest() != '7ada0605bca6b0530569c6454e988ace479606a3328ed591d090e5764fea661d':\n raise RuntimeError('D4 SWA3 manifest changed')\n grid = 'import numpy as np\\nfrom raptor_global_stack_smart336 import FixedGlobalStack, INFERRED96_WIDTHS\\n' + '\\n'.join((inspect.getsource(f) for f in (_dense_quotas, _dense_stack)))\n audit_dir = output.parent / 'study_input_receipts'\n audit_dir.mkdir(parents=True, exist_ok=True)\n for stale in audit_dir.glob('*.json*'):\n stale.unlink()\n output.unlink(missing_ok=True)\n output.with_suffix('.receipt.json').unlink(missing_ok=True)\n wrapper = output.parent / 'd4_worker_entry.py'\n code = f'import sys\\nsys.path.insert(0,{str(environment_dir)!r})\\nsys.path.insert(0,{str(artifact)!r})\\nfrom pathlib import Path\\nimport json\\nimport coatnet_d4_depthzone_swa_inference as rt\\n' + inspect.getsource(_asset_patch_d4) + '\\n' + inspect.getsource(_d4_check_runtime) + '\\n' + inspect.getsource(_d4_check_outputs) + '\\n' + f\"if __name__ == '__main__' and '--worker-output' not in sys.argv:\\n _checked_manifest, _checked_paths = _d4_check_runtime(rt, Path({str(artifact)!r}))\\n\" + f'_asset_patch_d4(rt,{grid!r})\\n' + 'rt.parent.audited.__file__ = __file__\\n' + \"if __name__ == '__main__':\\n\" + \" if '--worker-output' in sys.argv:\\n raise SystemExit(rt.main())\\n\" + ' manifest, paths = _checked_manifest, _checked_paths\\n' + ' r = rt.run_submission(\\n' + f' competition_root=Path({str(competition)!r}), artifact_root=Path({str(artifact)!r}),\\n' + f' output_path=Path({str(output)!r}), gpu_batch_studies=2, backbone_micro_images=8)\\n' + f' r = _d4_check_outputs(rt, manifest, r, Path({str(output)!r}), Path({str(competition)!r}))\\n' + f\" Path({str(output.with_suffix('.receipt.json'))!r}).write_text(json.dumps(r,indent=2,allow_nan=False))\\n\"\n compile(code, str(wrapper), 'exec')\n wrapper.write_text(code)\n env = dict(os.environ)\n env['RSNA_D4_INPUT_AUDIT_DIR'] = str(audit_dir)\n env['PYTHONPATH'] = f'{environment_dir}:/kaggle/working/_coat_env:{artifact}:' + env.get('PYTHONPATH', '')\n env.pop('CUDNN_CONV_WSCAP_DBG', None)\n _run_required_child([sys.executable, str(wrapper)], env, output.with_suffix('.log'))\n receipt = json.loads(output.with_suffix('.receipt.json').read_text())\n expected = pd.read_csv(Path(competition) / 'test.csv', dtype={'StudyInstanceUID': str}).StudyInstanceUID.tolist()\n records = []\n for path in sorted(audit_dir.glob('input_*.jsonl')):\n records.extend((json.loads(line) for line in path.read_text().splitlines() if line.strip()))\n ids = [r['study_uid'] for r in records]\n if len(ids) != len(expected) or len(ids) != len(set(ids)) or set(ids) != set(expected):\n raise RuntimeError('D4 input hook must execute exactly once for every test study')\n if not all((1 <= r['windows_expected'] <= 94 and r['positions'] == r['windows_expected'] + 2 for r in records)):\n raise RuntimeError('D4 input record cardinality drift')\n receipt['input_coverage'] = {'studies': len(records), 'folder': str(audit_dir), 'min_windows': min((r['windows_expected'] for r in records)), 'max_windows': max((r['windows_expected'] for r in records)), 'original_model_loader_retained': True, 'original_shard_scheduler_retained': True}\n output.with_suffix('.receipt.json').write_text(json.dumps(receipt, indent=2, allow_nan=False))\n return receipt\n_speed_original_asset_walk = _asset_walk\n_speed_original_find_asset = _asset_find_asset\n'Catalogue named immutable attachments once; no competition-tree search.'\nimport threading as _speed_threading\n_speed_asset_lock = _speed_threading.RLock()\n_speed_asset_catalogue = None\n_speed_asset_hits = {}\n\ndef _asset_walk():\n global _speed_asset_catalogue\n with _speed_asset_lock:\n if _speed_asset_catalogue is None:\n _speed_asset_catalogue = tuple(((root, tuple(dirs), tuple(files)) for root, dirs, files in _speed_original_asset_walk()))\n catalogue = _speed_asset_catalogue\n for root, dirs, files in catalogue:\n yield (root, list(dirs), list(files))\n\ndef _asset_find_asset(name, digest=None):\n key = (str(name), digest)\n with _speed_asset_lock:\n if key not in _speed_asset_hits:\n _speed_asset_hits[key] = _speed_original_find_asset(name, digest)\n return _speed_asset_hits[key]\n","metadata":{"tags":[]},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\n\ndef _dense_allocate(capacities, proportions, target):\n capacities = np.asarray(capacities, dtype=np.int64)\n proportions = np.asarray(proportions, dtype=np.float64)\n if capacities.ndim != 1 or capacities.shape != proportions.shape or np.any(capacities < 0) or (not np.isfinite(proportions).all()) or np.any(proportions <= 0) or (int(target) < 1):\n raise ValueError('invalid capacity-aware sampling allocation')\n ideal = int(target) * proportions / proportions.sum()\n initial = np.floor(ideal).astype(np.int64)\n for i in np.argsort(-(ideal - initial), kind='stable')[:int(target) - int(initial.sum())]:\n initial[i] += 1\n quotas = np.minimum(initial, capacities)\n wanted = min(int(target), int(capacities.sum()))\n deficit = np.zeros(len(quotas), dtype=np.float64)\n while int(quotas.sum()) < wanted:\n donors = quotas < capacities\n weights = np.where(donors, proportions, 0.0)\n deficit[donors] += weights[donors] / weights.sum()\n chosen = int(np.argmax(np.where(donors, deficit, -np.inf)))\n quotas[chosen] += 1\n deficit[chosen] -= 1\n assert int(quotas.sum()) == wanted and np.all(quotas <= capacities)\n return quotas\n\ndef _dense_unique_linspace(capacity, count):\n if not 0 <= count <= capacity:\n raise ValueError('cannot create unique picks beyond physical capacity')\n result = np.linspace(0, capacity - 1, count).round().astype(np.int64)\n if count and (result.min() < 0 or result.max() >= capacity):\n raise AssertionError('out-of-range source')\n assert len(np.unique(result)) == count\n return result\n\ndef _dense_coat_specs(study):\n import raptor_light224 as sampler\n capacities = []\n for row in study.series_rows:\n if int(row) < 0:\n capacities.append(0)\n else:\n centers, _, _, _ = sampler._candidate_centers(int(row), study.offsets, study.valid, study.source_depth)\n capacities.append(len(centers))\n if sum(capacities) < 1:\n raise ValueError('no usable CoAt triplets')\n quotas = _dense_allocate(capacities, (20, 12, 12, 8, 16, 8), 94)\n specs = sampler.sample_eval_windows(study.series_rows, study.offsets, study.valid, study.source_depth, count=None, slot_budgets=np.maximum(quotas, 1).tolist())\n if len(specs) != min(94, sum(capacities)):\n raise RuntimeError('capacity-aware sampling window-count drift')\n keys = [(s.series_row, s.center_local) for s in specs]\n if len(keys) != len(set(keys)):\n raise RuntimeError('capacity-aware sampling repeated a native center')\n for s in specs:\n start = int(study.offsets[s.series_row])\n if not np.all(study.valid[start + np.asarray(s.local_indices)]):\n raise RuntimeError('capacity-aware sampling invalid source channel')\n return specs\nINFERRED96_WIDTHS = (27, 21, 18, 12, 18)\n\ndef _dense_quotas(capacities) -> np.ndarray:\n capacities = np.asarray(capacities, dtype=np.int64)\n base = np.asarray(INFERRED96_WIDTHS, dtype=np.int64)\n if capacities.shape != (5,) or bool((capacities < 0).any()):\n raise ValueError('expected five nonnegative source capacities')\n quotas = np.minimum(base, capacities)\n target = min(96, int(capacities.sum()))\n deficit = np.zeros(5, dtype=np.float64)\n while int(quotas.sum()) < target:\n donors = quotas < capacities\n weights = np.where(donors, base, 0).astype(np.float64)\n deficit[donors] += weights[donors] / weights.sum()\n selected = int(np.argmax(np.where(donors, deficit, -np.inf)))\n quotas[selected] += 1\n deficit[selected] -= 1\n if int(quotas.sum()) != target or bool((quotas > capacities).any()):\n raise RuntimeError('additional quota allocation changed')\n return quotas\n\ndef _dense_stack(reference, offsets, valid, source_depth):\n from types import SimpleNamespace\n from raptor_global_stack_smart336 import FixedGlobalStack\n if tuple(reference.slot_widths) != tuple(INFERRED96_WIDTHS):\n raise ValueError('capacity-aware sampling is pinned to the Global96 reference layout')\n pools = []\n audit = []\n begin = 0\n for slot, width in enumerate(reference.slot_widths, 1):\n end = begin + width\n old = reference.global_indices[begin:end]\n row = int(reference.source_series_rows[begin])\n info = {'slot': slot, 'original_width': width, 'source_row': row}\n audit.append(info)\n if row < 0 or bool((old < 0).all()):\n pools.append((np.empty(0, dtype=np.int64), np.empty(0, dtype=np.float32)))\n begin = end\n continue\n start, stop = map(int, offsets[row:row + 2])\n if not 0 <= start < stop <= len(valid) == len(source_depth):\n raise ValueError('source offset drift')\n depth = np.asarray(source_depth[start:stop], dtype=np.float32)\n keep = np.asarray(valid[start:stop], dtype=bool) & np.isfinite(depth) & (depth >= 0.02) & (depth <= 0.98)\n eligible = np.flatnonzero(keep).astype(np.int64) + start\n reverse = bool(old[0] > old[-1] or (old[0] == old[-1] and np.float32(source_depth[old[0]]) != reference.canonical_depths[begin]))\n if reverse:\n eligible = eligible[::-1].copy()\n depth = np.asarray(source_depth[eligible], dtype=np.float32)\n if reverse:\n depth = (1.0 - depth).astype(np.float32)\n pools.append((eligible, depth))\n begin = end\n quotas = _dense_quotas([len(pool[0]) for pool in pools])\n if int(quotas.sum()) < 3:\n raise ValueError('study has fewer than three usable unique source slices')\n parts = {key: [] for key in ('global_indices', 'nominal_slots', 'canonical_depths', 'nominal_steps', 'source_series_rows', 'source_slot_ids')}\n for slot, ((eligible, depth), quota, info) in enumerate(zip(pools, quotas, audit), 1):\n quota = int(quota)\n info.update(eligible=len(eligible), allocated_width=quota, additional=max(0, quota - info['original_width']))\n info['reason'] = 'missing_no_padding' if not quota else 'short_slot_all_unique' if len(eligible) < info['original_width'] else 'uniform_native_centers' if info['additional'] else 'uniform_native_centers'\n positions = np.linspace(0, len(eligible) - 1, quota).round().astype(np.int64)\n if len(positions) != quota or not bool((np.diff(positions) > 0).all()):\n raise RuntimeError('capacity-aware sampling slot selection repeated a source')\n mask = reference.nominal_slots == slot\n source_slot = int(reference.source_slot_ids[mask][0])\n parts['global_indices'].append(eligible[positions])\n parts['canonical_depths'].append(depth[positions])\n parts['nominal_slots'].append(np.full(quota, slot, dtype=np.int8))\n parts['nominal_steps'].append(np.full(quota, 0.96 / max(quota - 1, 1), dtype=np.float32))\n parts['source_series_rows'].append(np.full(quota, info['source_row'], dtype=np.int32))\n parts['source_slot_ids'].append(np.full(quota, source_slot, dtype=np.int8))\n result = FixedGlobalStack(**{key: np.concatenate(value) for key, value in parts.items()}, slot_widths=tuple((int(value) for value in quotas)))\n if len(np.unique(result.global_indices)) != len(result.global_indices) or bool((result.global_indices < 0).any()):\n raise RuntimeError('capacity-aware sampling output contains a repeated/missing source')\n return (result, audit)\n","metadata":{"tags":[]},"outputs":[],"execution_count":null},{"cell_type":"code","source":"from __future__ import annotations\nimport time as _startup_time\n_STARTUP_T0 = _startup_time.perf_counter()\nimport os\nfor _v in ('OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS'):\n os.environ.setdefault(_v, '4')\nimport gc\nimport hashlib\nimport json\nimport re\nimport time\nimport traceback\nimport threading\nfrom concurrent.futures import ThreadPoolExecutor\nfrom pathlib import Path\nimport numpy as np\nimport pandas as pd\nimport pydicom\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\ndef _cuda_execution_probe(index):\n dev = torch.device(f'cuda:{index}')\n try:\n major, minor = torch.cuda.get_device_capability(index)\n probe = nn.Conv2d(3, 4, kernel_size=3, padding=1).eval().to(dev)\n with torch.inference_mode():\n out = probe(torch.zeros((1, 3, 16, 16), device=dev))\n if tuple(out.shape) != (1, 4, 16, 16):\n raise RuntimeError(f'unexpected CUDA probe shape {tuple(out.shape)}')\n torch.cuda.synchronize(index)\n print(f'cuda:{index} probe PASS (compute {major}.{minor})')\n del probe, out\n torch.cuda.empty_cache()\n return True\n except Exception as exc:\n print(f'cuda:{index} probe FAIL ({type(exc).__name__}: {exc}); rejecting device')\n try:\n torch.cuda.empty_cache()\n except Exception:\n pass\n return False\nDEVS = []\nif torch.cuda.is_available():\n DEVS = [torch.device(f'cuda:{i}') for i in range(torch.cuda.device_count()) if _cuda_execution_probe(i)]\nif len(DEVS) != 2:\n raise RuntimeError('This complete ensemble requires two working GPUs; no CPU/single-GPU partial fallback')\nif any('T4' not in torch.cuda.get_device_name(d) for d in DEVS):\n raise RuntimeError('Select the reference T4 x2 accelerator')\nprint(f'devices: {[str(d) for d in DEVS]}')\n_STARTUP_GPU_IMPORT_S = _startup_time.perf_counter() - _STARTUP_T0\nprint(f'[startup] imports+GPU preflight: {_STARTUP_GPU_IMPORT_S:.2f}s', flush=True)\nT0 = time.time()\nSEED = 2026\nnp.random.seed(SEED)\ntorch.manual_seed(SEED)\nTARGETS = ['ACL', 'MCL', 'Medial Meniscus', 'Lateral Meniscus', 'Medial OA', 'Lateral OA', 'PF OA', 'Effusion', 'Synovitis', \"Baker's\", 'Contusion', 'Fracture']\nCROP_MM = 130.0\nCACHE_IMG = 336\nGROUP = 3\nN_GROUP_MAX = 1\nCACHE_FRACTION = 0.45\nCACHE_BUDGET_MAX_GB = 24.0\nCACHE_BUDGET_GB = 12.0\nTEST_SHARE = 0.3\nHDR_THREADS = 16\nPIX_THREADS = 12\nORDER_THREADS = 32\nORDER_BUDGET_S = 5400\nRUNS = [{'name': 'r224', 'img': 224}, {'name': 'r336', 'img': 336}]\nEPOCHS = 10\nBATCH_STUDIES = 8\nAUG_ROT_DEG = 8.0\nAUG_SCALE = 0.08\nAUG_SHIFT = 0.05\nAUG_INTENSITY = 0.1\nLAT_MIN_OFFSET_MM = 20.0\nSLICE_BAND = (0.2, 0.8)\nRULES_NATIVE = {'order': 'normal', 'lat': 'centre', 'slot_fallback': False, 'decode_fill': 'nearest'}\nRULES_LEGACY = {'order': 'dominant_axis', 'lat': 'corner_x', 'slot_fallback': True, 'decode_fill': 'zero'}\nRULES = dict(RULES_NATIVE)\nLEGACY_LAT_OFFSET_MM = 5.0\nLR_HEAD = 0.001\nLR_BACKBONE = 8e-06\nUNFREEZE_LAST = 6\nWEIGHT_DECAY = 0.02\nEVAL_BATCH = 8\nTIME_BUDGET = 8.0 * 3600\nSLOTS_RECOVERED = [('SAG_FLUID_FS', 'Sagittal', True, True), ('COR_FLUID_FS', 'Coronal', True, True), ('AX_FLUID_FS', 'Axial', True, True), ('SAG_FLUID_NOFS', 'Sagittal', True, False), ('COR_T1', 'Coronal', False, False), ('SAG_T1', 'Sagittal', False, False)]\nSLOTS_PUBLIC = [('SAG_FLUID', 'Sagittal', None, True), ('COR_FLUID', 'Coronal', None, True), ('AX_FLUID', 'Axial', None, True), ('SAG_STRUCT', 'Sagittal', None, False), ('COR_STRUCT', 'Coronal', None, False), ('AX_STRUCT', 'Axial', None, False)]\nSLOT_SCHEME = os.environ.get('SLOT_SCHEME', 'recovered')\nSLOTS = SLOTS_PUBLIC if SLOT_SCHEME == 'public' else SLOTS_RECOVERED\nN_SLOT = len(SLOTS)\nPOOL_PARTS = {'cls_mean': 2, 'cls_mean_focal': 3}\nSLOT_PRIOR_TABLE = {'ACL': (0, 3, 5), 'MCL': (1, 4), 'Medial Meniscus': (0, 1, 3, 4), 'Lateral Meniscus': (0, 1, 3, 4), 'Medial OA': (1, 4, 5), 'Lateral OA': (1, 4, 5), 'PF OA': (0, 2, 5), 'Effusion': (0, 2), 'Synovitis': (0, 2), \"Baker's\": (0,), 'Contusion': (0, 1, 2), 'Fracture': (0, 1, 2, 4, 5)}\nSLOT_PRIOR_STRENGTH = 0.55\nFATSAT_OPTS = {'FS', 'FATSAT', 'FAT_SAT', 'FSAT'}\n_SEP = re.compile('[_\\\\-.]')\n_FATSAT_RX = re.compile('\\\\bfs\\\\b|fatsat|fat sat|\\\\bstir\\\\b|\\\\bspair\\\\b|\\\\bspir\\\\b|\\\\bwe\\\\b|water excit|\\\\btirm\\\\b|\\\\bsting\\\\b|\\\\bfatsup\\\\b|smart fat|\\\\bwater\\\\b') # 2026-09-17: GE Dixon water images ('SMART FAT', 'Water: SMART FAT', seq FSEfw) are fat-suppressed; 37/4407 training studies had no fat-sat series detected before\n_T1_RX = re.compile('\\\\bt1\\\\b|\\\\bt1w\\\\b')\n_T2_RX = re.compile('\\\\bt2\\\\b|\\\\bt2w\\\\b')\n_PD_RX = re.compile('\\\\bpd\\\\b|\\\\bpdw\\\\b|proton|\\\\bdp\\\\b|dens')\n\n# Runtime integrity: no partial ensemble is ever published as submission.csv.\nimport os, json, hashlib, time, threading, tempfile\nfrom pathlib import Path\nimport numpy as np\nimport pandas as pd\n\n_RSNA_AUDIT_LOCK = threading.RLock()\n_RSNA_AUDIT = {'contract': 'btkd_speedy_v558_input_uniform', 'events': [], 'phases': {}}\n_RSNA_ORDER_MEMO = {}\n_RSNA_HEADERS_MEMO = {}\n_RSNA_CACHE_FILES = []\n_RSNA_TEST_IDS = None\n_RSNA_LABELS = ['ACL','MCL','Medial Meniscus','Lateral Meniscus','Medial OA','Lateral OA','PF OA','Effusion','Synovitis',\"Baker's\",'Contusion','Fracture']\n\ndef rsna_sha(path):\n h = hashlib.sha256()\n with Path(path).open('rb') as f:\n for b in iter(lambda: f.read(8 << 20), b''):\n h.update(b)\n return h.hexdigest()\n\ndef rsna_json(path, value):\n path = Path(path); path.parent.mkdir(parents=True, exist_ok=True)\n tmp = path.with_name('.' + path.name + '.tmp')\n with tmp.open('w') as f:\n json.dump(value, f, indent=2, sort_keys=True, allow_nan=False, default=str)\n f.write('\\n'); f.flush(); os.fsync(f.fileno())\n os.replace(tmp, path)\n\ndef rsna_event(kind, **details):\n with _RSNA_AUDIT_LOCK:\n _RSNA_AUDIT['events'].append({'kind':kind, **details})\n\ndef rsna_finite(values, tag, probability=False):\n x = np.asarray(values)\n if not np.issubdtype(x.dtype, np.number) or not np.isfinite(x).all():\n raise RuntimeError(f'{tag}: nonfinite/non-numeric values BEFORE ranking')\n if probability and x.size and (x.min() < 0 or x.max() > 1):\n raise RuntimeError(f'{tag}: probability outside [0,1]')\n return x\n\ndef rsna_rank01(values):\n \"\"\"Parent endpoint scale; tied values share their average rank.\"\"\"\n x = np.asarray(rsna_finite(values, 'rank01'), dtype=np.float64)\n if x.ndim != 2 or not len(x):\n raise ValueError('rank01 requires a nonempty [study,finding] matrix')\n if len(x) == 1:\n return np.full_like(x, .5)\n return (pd.DataFrame(x).rank(method='average').to_numpy() - 1) / (len(x)-1)\n\ndef rsna_rankpct(values):\n x = np.asarray(rsna_finite(values, 'rankpct'), dtype=np.float64)\n if x.ndim != 2 or not len(x):\n raise ValueError('rankpct requires a nonempty matrix')\n return pd.DataFrame(x).rank(method='average', pct=True).to_numpy(np.float64)\n\ndef rsna_frame(frame, ids, labels, tag):\n ids = [str(u) for u in ids]; labels = list(labels)\n if len(ids) != len(set(ids)):\n raise RuntimeError(f'{tag}: duplicate expected UID')\n if frame.columns.tolist() != ['StudyInstanceUID', *labels]:\n raise RuntimeError(f'{tag}: label order/schema mismatch')\n frame = frame.copy(); frame['StudyInstanceUID'] = frame['StudyInstanceUID'].astype(str)\n if frame.StudyInstanceUID.duplicated().any() or set(frame.StudyInstanceUID) != set(ids):\n raise RuntimeError(f'{tag}: missing/extra/duplicate UID')\n frame = frame.set_index('StudyInstanceUID').loc[ids].reset_index()\n rsna_finite(frame[labels].to_numpy(), tag, probability=True)\n return frame\n\ndef rsna_save_predictions(tag, ids, values, labels=None):\n x = rsna_finite(values, tag)\n target = Path('/kaggle/working/diagnostics'); target.mkdir(parents=True, exist_ok=True)\n path = target/(tag+'.npz')\n np.savez_compressed(path, study_uids=np.asarray(ids,dtype=str), labels=np.asarray(labels or _RSNA_LABELS,dtype=str), values=x)\n with _RSNA_AUDIT_LOCK:\n _RSNA_AUDIT['phases'][tag]={'path':str(path),'sha256':rsna_sha(path),'shape':list(x.shape)}\n\ndef rsna_strict_load(model, state, tag):\n \"\"\"A random frozen encoder is never an acceptable missing-state fallback.\"\"\"\n expected = model.state_dict()\n missing = sorted(set(expected)-set(state)); extra = sorted(set(state)-set(expected))\n bad_shape = [k for k in set(expected)&set(state) if tuple(expected[k].shape)!=tuple(state[k].shape)]\n if missing or extra or bad_shape:\n raise RuntimeError(f'{tag}: incomplete/mismatched checkpoint; missing={missing[:20]}, extra={extra[:20]}, shapes={bad_shape[:20]}. A partial encoder needs its exact pinned source weights; random initialization is forbidden.')\n for k,t in state.items():\n if t.is_floating_point() and not bool(t.isfinite().all()):\n raise RuntimeError(f'{tag}: nonfinite checkpoint tensor {k}')\n return model.load_state_dict(state, strict=True)\n\ndef rsna_deadline(tag):\n if time.time() - T0 > TIME_BUDGET:\n raise TimeoutError(f'{tag}: full-run budget exceeded; no incomplete output may be submitted')\n\ndef rsna_array(shape, tag):\n \"\"\"Large temporary pixels belong in scratch space, not saved notebook outputs.\"\"\"\n size = int(np.prod(shape))\n if size <= float(os.environ.get('RSNA_CACHE_RAM_GIB', '1')) * (1 << 30):\n return np.zeros(shape, np.uint8)\n directory = Path(os.environ.get('RSNA_PIXEL_SCRATCH', '/kaggle/temp/rsna_pixels_v559'))\n try:\n directory.mkdir(parents=True, exist_ok=True)\n except OSError as scratch_error: # /kaggle/temp is not guaranteed; /tmp is non-persisted scratch with ~1 TiB free\n rsna_event('scratch_fallback', tag=tag, requested=str(directory), error=f'{type(scratch_error).__name__}: {scratch_error}')\n directory = Path('/tmp/rsna_pixels_v559')\n directory.mkdir(parents=True, exist_ok=True)\n import shutil\n free = shutil.disk_usage(directory).free\n rsna_event('scratch_allocation', tag=tag, bytes=size, directory=str(directory), free_bytes=int(free))\n if free < size + (1 << 30) and str(directory) != '/tmp/rsna_pixels_v559':\n rsna_event('scratch_fallback', tag=tag, requested=str(directory), error=f'insufficient free space ({free} bytes)')\n directory = Path('/tmp/rsna_pixels_v559'); directory.mkdir(parents=True, exist_ok=True); free = shutil.disk_usage(directory).free\n if free < size + (1 << 30):\n raise RuntimeError(f'{tag}: not enough scratch disk for complete cache ({size} bytes; {free} free)')\n fd, path = tempfile.mkstemp(prefix='pixels_', suffix='.npy', dir=directory)\n os.close(fd)\n try:\n a = np.lib.format.open_memmap(path, mode='w+', dtype=np.uint8, shape=tuple(shape))\n a[:] = 0\n except BaseException:\n Path(path).unlink(missing_ok=True)\n raise\n _RSNA_CACHE_FILES.append(path)\n return a\n\ndef rsna_release_pixels(array):\n if isinstance(array,np.memmap):\n path=str(array.filename)\n array.flush()\n # POSIX unlink releases the file after the last view is closed.\n Path(path).unlink(missing_ok=True)\n if path in _RSNA_CACHE_FILES: _RSNA_CACHE_FILES.remove(path)\n\ndef rsna_initialize(ids):\n global _RSNA_TEST_IDS\n _RSNA_TEST_IDS=[str(u) for u in ids]\n if not _RSNA_TEST_IDS or len(set(_RSNA_TEST_IDS))!=len(_RSNA_TEST_IDS):\n raise RuntimeError('empty or duplicate competition study IDs')\n work=Path('/kaggle/working'); work.mkdir(parents=True,exist_ok=True)\n os.chdir(work)\n for f in ['submission.csv','_pipeline_stage.csv','btkd_v559_complete.json','btkd_v559_complete.json']:\n (work/f).unlink(missing_ok=True)\n (work/'diagnostics').mkdir(exist_ok=True)\n _RSNA_AUDIT['cohort']=len(_RSNA_TEST_IDS)\n _RSNA_AUDIT['environment']={'python':__import__('sys').version,'torch':str(torch.__version__),'cuda':torch.version.cuda,'gpu_names':[torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())]}\n rsna_json(work/'diagnostics/runtime_started.json',_RSNA_AUDIT)\n\ndef rsna_asset_preflight():\n \"\"\"Locate required additions before spending time on the public parent.\"\"\"\n names=['raptor_ft_coatnet_v5_full_swa.pt','raptor_ft_coatnet_v10_full.pt','raptor_ft_coatnet_v8_full_swa.pt']\n receipt={name:str(_asset_find_asset(name)) for name in names}\n for name,digest in [\n ('coat_resgated_ep10_top3_manifest.json','98511a8fdeb9da0e6e70c78d013ff636e1476f31c80b5dc134d294b18c3f284e'),\n ('coatnet_pairfilm_manifest.json','7ada0605bca6b0530569c6454e988ace479606a3328ed591d090e5764fea661d'),\n ('opencv_python_headless-4.12.0.88-*.whl','236c8df54a90f4d02076e6f9c1cc763d794542e886c576a6fee46ec8ff75a7a9')]:\n receipt[name]={'path':str(_asset_find_asset(name,digest)),'sha256':digest}\n roots=[Path(p) for p in ['/kaggle/input/datasets/mattiaangeli/knee-mri-fold-weights','/kaggle/input/knee-mri-fold-weights'] if (Path(p)/'m_f0.pt').is_file()]\n roots=list({str(p.resolve()):p for p in roots}.values())\n if len(roots)!=1:raise RuntimeError(f'A5: expected one complete attached root, found {roots}')\n missing=[str(roots[0]/f'm_f{i}.pt') for i in range(5) if not (roots[0]/f'm_f{i}.pt').is_file()]\n if missing:raise FileNotFoundError(f'A5 missing folds: {missing}')\n receipt['A5_root']=str(roots[0]);receipt['tensor_loading_and_fingerprints']='validated by mandatory component loaders before predictions'\n d4_manifest_path = _asset_find_asset('coatnet_pairfilm_manifest.json',\n '7ada0605bca6b0530569c6454e988ace479606a3328ed591d090e5764fea661d')\n timm_wheel = d4_manifest_path.parent / 'timm-1.0.22-py3-none-any.whl'\n if not timm_wheel.is_file() or rsna_sha(timm_wheel) != '888981753e65cbaacfc07494370138b1700a27b1f0af587f4f9b47bc024161d0':\n raise RuntimeError('D4 pinned timm wheel missing or changed')\n receipt['D4_timm_wheel_sha256'] = rsna_sha(timm_wheel)\n rsna_json('/kaggle/working/diagnostics/asset_preflight.json',receipt)\n\n\ndef rsna_phase(stage, status='START', **extra):\n \"\"\"Local phase evidence; this does not expose Kaggle's hidden rerun logs.\"\"\"\n import json, os, resource, time\n from pathlib import Path\n work = Path('/kaggle/working/diagnostics')\n work.mkdir(parents=True, exist_ok=True)\n current = {'stage': stage, 'status': status,\n 'elapsed_seconds': time.time()-T0,\n 'max_rss_kib': int(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss), **extra}\n for path in ['/sys/fs/cgroup/memory.current', '/sys/fs/cgroup/memory.max']:\n try: current[path.rsplit('/', 1)[-1]] = Path(path).read_text().strip()\n except OSError: pass\n if torch.cuda.is_initialized():\n current['gpus'] = [{'id': i, 'allocated_bytes': torch.cuda.memory_allocated(i),\n 'reserved_bytes': torch.cuda.memory_reserved(i)}\n for i in range(torch.cuda.device_count())]\n print('[phase] '+json.dumps(current, sort_keys=True), flush=True)\n rsna_json(work/'current_phase.json', current)\n with (work/'phase_events.jsonl').open('a') as f:\n f.write(json.dumps(current, sort_keys=True)+'\\n')\n return current\n\n# Record uncaught cell errors locally; Kaggle may still withhold hidden-run logs.\ndef _rsna_capture_cell_error(result):\n error = getattr(result, 'error_in_exec', None) or getattr(result, 'error_before_exec', None)\n if error is None:\n return\n try:\n path = Path('/kaggle/working/diagnostics/current_phase.json')\n previous = json.loads(path.read_text()) if path.is_file() else {}\n rsna_phase(previous.get('stage', 'unknown'), 'FAILED', error_type=type(error).__name__, error=str(error))\n except Exception as logging_error:\n print('[diagnostic-write-failed]', type(logging_error).__name__, flush=True)\ntry:\n _rsna_ip = get_ipython()\n if _rsna_ip is not None:\n _rsna_ip.events.register('post_run_cell', _rsna_capture_cell_error)\nexcept NameError:\n pass\n","metadata":{"tags":[]},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def log(msg):\n print(f'[{time.time() - T0:7.1f}s] {msg}', flush=True)\n\ndef _one_direct(tag, candidates, required):\n matches = []\n for candidate in map(Path, candidates):\n if candidate.is_dir() and all((candidate / item).exists() for item in required):\n matches.append(candidate)\n unique = []\n for match in matches:\n if str(match.resolve()) not in {str(item.resolve()) for item in unique}:\n unique.append(match)\n if len(unique) != 1:\n raise FileNotFoundError(\n f'{tag}: expected exactly one direct mounted artifact, found '\n f'{[str(item) for item in unique]}; checked {[str(Path(item)) for item in candidates]}'\n )\n return unique[0]\n\ndef find_root():\n return _one_direct('competition', [\n os.environ.get('RSNA_COMP_ROOT', '/kaggle/input/competitions/rsna-knee-abnormality-detection'),\n '/kaggle/input/rsna-knee-abnormality-detection',\n ], ['test.csv', 'test_series.csv', 'test_series'])\n\ndef find_dinov2(variant='small'):\n if variant != 'small':\n raise ValueError(f'unpinned DINOv2 variant: {variant}')\n return _one_direct('DINOv2-S model', [\n '/kaggle/input/models/metaresearch/dinov2/PyTorch/small/1',\n '/kaggle/input/models/metaresearch/dinov2/pytorch/small/1',\n '/kaggle/input/dinov2/PyTorch/small/1',\n '/kaggle/input/dinov2/pytorch/small/1',\n ], ['config.json', 'pytorch_model.bin'])\nROOT = find_root()\nDINOV2_SOURCE = find_dinov2('small')\nlog(f'input root: {ROOT}')\n_STARTUP_PATH_S = _startup_time.perf_counter() - _STARTUP_T0 - _STARTUP_GPU_IMPORT_S\nprint(f'[startup] competition-root preflight: {_STARTUP_PATH_S:.2f}s', flush=True)\nIMG = CACHE_IMG\n\ndef available_gb():\n try:\n with open('/proc/meminfo') as fh:\n info = {k.strip(): v for k, v in (l.split(':', 1) for l in fh if ':' in l)}\n return int(info['MemAvailable'].split()[0]) / 1024 ** 2\n except Exception:\n return CACHE_BUDGET_GB / CACHE_FRACTION\n\ndef plan_cache(n_study, n_test=0):\n avail = available_gb()\n budget = min(avail * CACHE_FRACTION, CACHE_BUDGET_MAX_GB)\n n_total = n_study + max(n_test, int(TEST_SHARE * n_study))\n per_slice = n_total * N_SLOT * IMG * IMG\n afford = int(budget * 1024 ** 3 // max(per_slice, 1))\n groups = max(1, min(N_GROUP_MAX, afford // GROUP))\n log(f'memory: {avail:.1f} GB available, {budget:.1f} GB to the cache; sizing for {n_study} train + {n_total - n_study} test studies -> {groups} group(s) of {GROUP} = {groups * GROUP} slices per slot' + (f' (wanted {N_GROUP_MAX})' if groups < N_GROUP_MAX else ''))\n return groups\nN_GROUP = plan_cache(len(pd.read_csv(ROOT / 'train.csv')), len(pd.read_csv(ROOT / 'test.csv')))\nCACHE_SLICES = GROUP * N_GROUP\nlog(f'cache layout: {N_GROUP} groups x {GROUP} slices = {CACHE_SLICES} per slot')\nrsna_initialize(pd.read_csv(ROOT/'test.csv',dtype={'StudyInstanceUID':str}).StudyInstanceUID.tolist())\nos.environ['RSNA_COMP_ROOT']=str(ROOT)\nrsna_asset_preflight()\n\n# Resolve unsupported A5 metadata before long model inference, without inventing labels.\n_meta = pd.read_csv(ROOT/'test_series.csv', dtype={'StudyInstanceUID':str})\n_required = {'StudyInstanceUID','Anatomical_Plane','Fat_Suppression'}\nif not _required.issubset(_meta.columns):\n raise RuntimeError('Missing required series metadata columns: '+str(sorted(_required-set(_meta.columns))))\n_a5_matches = _meta.Anatomical_Plane.isin(['Sagittal','Coronal','Axial']) & _meta.Fat_Suppression.isin([0,1])\n_a5_ids = set(_meta.loc[_a5_matches,'StudyInstanceUID'])\n_a5_unavailable = [u for u in _RSNA_TEST_IDS if u not in _a5_ids]\nrsna_json('/kaggle/working/diagnostics/a5_metadata_applicability.json', {\n 'studies':len(_RSNA_TEST_IDS), 'no_matching_acquisition_uids':_a5_unavailable,\n 'policy':'base-only contribution for explicit A5 absence; model failures remain fatal'})\nrsna_phase('input_metadata', 'COMPLETE', a5_without_matching_acquisition=len(_a5_unavailable),\n missing_fluid_flags=int(_meta.Fluid_Sensitive.isna().sum()) if 'Fluid_Sensitive' in _meta else len(_meta))\ndel _meta, _a5_matches, _a5_ids, _a5_unavailable\n","metadata":{"tags":[]},"outputs":[],"execution_count":null},{"cell_type":"code","source":"HDR_TAGS = ['SeriesDescription', 'SequenceName', 'ScanOptions', 'ScanningSequence', 'RepetitionTime', 'EchoTime', 'Laterality', 'PixelSpacing', 'Rows', 'Columns', 'RescaleSlope', 'RescaleIntercept', 'ImagePositionPatient', 'ImageOrientationPatient']\n\ndef _hdr_vec(s, n):\n if not isinstance(s, str):\n return None\n try:\n v = [float(x) for x in s.split('|')]\n except ValueError:\n return None\n return np.array(v) if len(v) >= n else None\n\ndef side_from_geometry(h):\n cx = {}\n for r in h.itertuples(index=False):\n ipp = _hdr_vec(getattr(r, 'ImagePositionPatient', None), 3)\n iop = _hdr_vec(getattr(r, 'ImageOrientationPatient', None), 6)\n ps = _hdr_vec(getattr(r, 'PixelSpacing', None), 2)\n rows, cols = (getattr(r, 'Rows', None), getattr(r, 'Columns', None))\n if ipp is None or iop is None or ps is None or (not rows) or (not cols):\n continue\n try:\n c = ipp[:3] + iop[:3] * ps[1] * float(cols) / 2 + iop[3:6] * ps[0] * float(rows) / 2\n except (TypeError, ValueError):\n continue\n cx.setdefault(r.StudyInstanceUID, []).append(float(c[0]))\n out = {}\n for st, xs in cx.items():\n m = float(np.median(xs))\n out[st] = None if abs(m) < LAT_MIN_OFFSET_MM else 'R' if m < 0 else 'L'\n return out\n\ndef side_from_corner_x(h):\n out = {}\n for st, g in h.groupby('StudyInstanceUID'):\n xs = []\n for r in g.itertuples(index=False):\n ipp = _hdr_vec(getattr(r, 'ImagePositionPatient', None), 3)\n if ipp is not None and np.isfinite(ipp).all():\n xs.append(float(ipp[0]))\n if not xs:\n out[st] = None\n continue\n x = float(np.median(xs))\n out[st] = None if abs(x) < LEGACY_LAT_OFFSET_MM else 'R' if x < 0 else 'L'\n return out\n\ndef lat_of(h, tag=''):\n geo = side_from_corner_x(h) if RULES['lat'] == 'corner_x' else side_from_geometry(h)\n d, n_tag, n_geo, n_none, n_disagree = ({}, 0, 0, 0, 0)\n for st, g in h.groupby('StudyInstanceUID'):\n v = [str(x).strip().upper() for x in g['Laterality'].dropna()]\n if RULES['lat'] == 'corner_x' and 'ImageLaterality' in g.columns:\n v += [str(x).strip().upper() for x in g['ImageLaterality'].dropna()]\n v = [x[0] for x in v if x and x[0] in ('L', 'R')]\n side = v[0] if v else None\n if side is not None:\n n_tag += 1\n if geo.get(st) is not None and geo[st] != side:\n n_disagree += 1\n else:\n side = geo.get(st)\n n_geo += side is not None\n n_none += side is None\n d[st] = side\n log(f'{tag}laterality: {n_tag} from the tag, {n_geo} from geometry, {n_none} unresolved; tag and geometry disagree on {n_disagree} ({n_disagree / max(n_tag, 1):.1%} of the tagged)')\n return d\n\ndef probe(item):\n split, study, series, path = item\n row = {'split': split, 'StudyInstanceUID': study, 'SeriesInstanceUID': series, 'dir': path}\n try:\n files = sorted((e.name for e in os.scandir(path) if e.name.endswith('.dcm')))\n row['files'] = files\n row['n_slices'] = len(files)\n if not files:\n return row\n ds = pydicom.dcmread(os.path.join(path, files[len(files) // 2]), stop_before_pixels=True, force=True)\n for t in HDR_TAGS:\n v = getattr(ds, t, None)\n if v is None:\n row[t] = None\n elif isinstance(v, (list, tuple)) or type(v).__name__ == 'MultiValue':\n row[t] = '|'.join((str(x) for x in v))\n else:\n row[t] = str(v)\n except Exception as exc:\n row['err'] = str(exc)[:120]\n return row\n\ndef walk(split):\n key=(str(ROOT.resolve()),str(split))\n if key in _RSNA_HEADERS_MEMO:\n return _RSNA_HEADERS_MEMO[key].copy(deep=True)\n base = ROOT / split\n items = []\n if not base.is_dir():\n return pd.DataFrame(columns=['split', 'StudyInstanceUID', 'SeriesInstanceUID', 'dir', 'files', 'n_slices'] + HDR_TAGS)\n for study in os.scandir(base):\n if study.is_dir():\n for series in os.scandir(study.path):\n if series.is_dir():\n items.append((split, study.name, series.name, series.path))\n with ThreadPoolExecutor(max_workers=HDR_THREADS) as pool:\n rows = list(pool.map(probe, items))\n result=pd.DataFrame(rows)\n _RSNA_HEADERS_MEMO[key]=result.copy(deep=True)\n return result\n\ndef annotate(df):\n desc = df['SeriesDescription'].fillna('') + ' ' + df['SequenceName'].fillna('')\n desc = desc.str.lower().str.replace(_SEP, ' ', regex=True)\n opts = df['ScanOptions'].fillna('').str.upper().str.split('|')\n opts_fs = opts.apply(lambda ts: any((t.strip() in FATSAT_OPTS for t in ts)))\n df['fatsat'] = desc.str.contains(_FATSAT_RX) | opts_fs\n tr = pd.to_numeric(df['RepetitionTime'], errors='coerce')\n te = pd.to_numeric(df['EchoTime'], errors='coerce')\n gre = df['ScanningSequence'].fillna('').str.upper().str.contains('GR')\n t1, t2, pdw = (desc.str.contains(_T1_RX), desc.str.contains(_T2_RX), desc.str.contains(_PD_RX))\n df['weight'] = np.where(t1 & ~t2 & ~pdw, 'T1', np.where(t2 & ~pdw, 'T2', np.where(pdw, 'PD', np.where(gre, 'GRE', np.where(tr < 800, 'T1', np.where(te > 60, 'T2', np.where(tr >= 800, 'PD', 'UNK')))))))\n df['fluid'] = np.isin(df['weight'], ['PD', 'T2'])\n df['px'] = pd.to_numeric(df['PixelSpacing'].fillna('').str.split('|').str[0].replace('', np.nan), errors='coerce')\n return df\n","metadata":{"tags":[]},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def pick_slots(series_df, plane_map):\n series_df = series_df.copy()\n series_df['plane'] = series_df['SeriesInstanceUID'].map(plane_map)\n out = {}\n for study, g in series_df.groupby('StudyInstanceUID'):\n chosen = {}\n for name, plane, fluid, fs in SLOTS:\n sel = (g['plane'] == plane) & (g['fatsat'] == fs)\n if fluid is not None:\n sel &= g['fluid'] == fluid\n cand = g[sel]\n if len(cand) == 0 and RULES['slot_fallback'] and (fluid is False):\n cand = g[(g['plane'] == plane) & ~g['fatsat']]\n if len(cand):\n chosen[name] = cand.sort_values('n_slices', ascending=False).iloc[0]\n out[study] = chosen\n return out\n","metadata":{"tags":[]},"outputs":[],"execution_count":null},{"cell_type":"code","source":"ORDER_TAGS = [(32, 50), (32, 55), (32, 19)]\nDECODE_FAILED = []\n\n\ndef _natural_key(name):\n return tuple((int(x) if x.isdigit() else x.lower() for x in re.split('(\\\\d+)', str(name))))\n\ndef _order_dominant_axis(rec):\n files, d = (rec['files'], rec['dir'])\n rows = []\n for pos, f in enumerate(files):\n ipp = inst = None\n try:\n ds = pydicom.dcmread(os.path.join(d, f), force=True, stop_before_pixels=True, specific_tags=['ImagePositionPatient', 'InstanceNumber'])\n raw = getattr(ds, 'ImagePositionPatient', None)\n if raw is not None and len(raw) >= 3:\n c = np.asarray(raw[:3], dtype=np.float64)\n if np.isfinite(c).all():\n ipp = c\n n = getattr(ds, 'InstanceNumber', None)\n if n is not None:\n inst = float(n)\n except Exception:\n pass\n rows.append((f, ipp, inst, pos))\n placed = [r for r in rows if r[1] is not None]\n need = max(2, int(0.8 * len(rows)))\n if len(placed) >= need:\n xyz = np.stack([r[1] for r in placed])\n axis = int(np.argmax(np.ptp(xyz, axis=0)))\n spare = float(np.nanmedian(xyz[:, axis]))\n rows.sort(key=lambda r: (float(r[1][axis]) if r[1] is not None else spare, r[2] if r[2] is not None else float('inf'), r[3]))\n elif sum((r[2] is not None for r in rows)) >= need:\n rows.sort(key=lambda r: (r[2] if r[2] is not None else float('inf'), r[3]))\n else:\n rows.sort(key=lambda r: _natural_key(r[0]))\n return ([r[0] for r in rows], True)\n\ndef order_slices(rec):\n if RULES['order'] == 'dominant_axis':\n return _order_dominant_axis(rec)\n files, d = (rec['files'], rec['dir'])\n keyed = []\n for f in files:\n k = None\n ds = None\n try:\n ds = pydicom.dcmread(os.path.join(d, f), force=True, stop_before_pixels=True, specific_tags=ORDER_TAGS)\n iop = np.asarray(ds.ImageOrientationPatient, dtype=float)\n ipp = np.asarray(ds.ImagePositionPatient, dtype=float)\n k = float(np.dot(ipp, np.cross(iop[:3], iop[3:])))\n except Exception:\n try:\n k = float(ds.InstanceNumber)\n except Exception:\n k = None\n keyed.append((k, f))\n if any((k is None for k, _ in keyed)):\n return (sorted(files,key=_natural_key), False)\n return ([f for _, f in sorted(keyed, key=lambda t: t[0])], True)\n\ndef read_slot(rec, n_slice=None, out_size=None):\n \"\"\"Same healthy pixels as BTKD; failed slices cannot erase good native planes.\"\"\"\n n_slice = GROUP if n_slice is None else int(n_slice)\n out_size = IMG if out_size is None else int(out_size)\n files, d, px = rec.get('ordered') or rec['files'], rec['dir'], rec['px']\n if not files:\n rsna_event('slot_no_files', series=str(rec.get('SeriesInstanceUID', d)), dir=str(d))\n return None\n lo, hi = int(SLICE_BAND[0]*(len(files)-1)), int(SLICE_BAND[1]*(len(files)-1))\n idx = np.unique(np.linspace(lo,hi,n_slice).astype(int)) if hi>lo else np.array([len(files)//2])\n while len(idx)0:\n want=int(round(CROP_MM/px)); h,w=shape\n if 16