{"cells":[{"cell_type":"markdown","metadata":{},"source":"# RSNA Knee — fast 2xT4 inference\n\n## Mini changelog\n\n- **v2:** reorganized inference for two T4s: shared the frozen DINO prefix,\n overlapped CPU preparation, shared MaxSpan decoding, and bounded cuDNN memory.\n- **v3:** changed Raptor MaxSpan forward/reverse weights from **0.55/0.15** to\n **0.60/0.10**; Native384 Dense/Native384 stayed **0.10/0.20**.\n- **v4:** cached immutable DICOM slice order and spacing across Raptor views.\n- **v5:** removed a redundant Raptor rerank, matching the public 0.941 recipe.\n- **v6:** passed DINO's verified slice order and spacing into Raptor, avoiding a\n second header scan while retaining the original fallback for ambiguous series.\n- **v7:** adopts the current public **0.942** recipe: residual-gated CoAtNet and\n D4 DepthZone SWA3 ranks are mixed **0.50/0.50**; that private family remains\n **0.40** against public Raptor **0.60**, with no inner rerank. RadImageNet's\n main/second-pass weights change **0.50→0.55** and **0.15→0.20**.\n- **v8:** runs the independent residual-gated and D4 readers concurrently on\n both T4s. Checkpoints, windows, precision, and weights are unchanged; their\n 30-study local wall time fell from **155.2s→69.4s** with zero fallbacks.\n\nThis inference-only notebook is derived from\n[maverickss26's public solution](https://www.kaggle.com/code/maverickss26/rsna-knee-0941-restructured)\nand the scored v7 method comes directly from\n[Mattia Angeli's Speedy Raptors v11](https://www.kaggle.com/code/mattiaangeli/bend-the-knee-to-speedy-raptors?scriptVersionId=350854753).\nThe exact archived implementation is cross-checked against\n[Berat Erol Celik's v5](https://www.kaggle.com/code/beraterolelk/rsna-knee-speedy-raptors-coatnet-d4-sota?scriptVersionId=351068470).\nBoth score 0.942 publicly. Thanks also to Dread Development, Pilkwang Kim,\nSofia Anjenje, Antoine G., prvsiyan, Marwan Mahmoud, renta.k, and Anvith Pothula\nfor the released models and upstream work.\n\n## Model stack\n\n| Stage | Inference family | Fusion role |\n|---|---|---|\n| 1 | 20 DINO slot-attention members | transformer base |\n| 2 | five A5 attention-pooling folds | 45% update to the base |\n| 3 | RadImageNet E10/E13/E11 heads | calibrated transformer branch |\n| 4 | four Raptor views | public CoAtNet branch |\n| 5 | residual CoAtNet top-3 + D4 DepthZone SWA3 | 50/50 private CoAt family |\n\n## Why it is fast\n\n- DINO members share their identical frozen six-block prefix.\n- CPU preparation overlaps GPU inference for A5 and RadImageNet.\n- MaxSpan forward/reverse views share one decode and checkpoint load.\n- Raptor uses two balanced GPU workers, a bounded pixel cache, and capacity-aware\n unique windows. DINO's existing header scan also seeds Raptor's ordering cache.\n- The two complementary CoAtNet readers overlap their independent preparation\n and inference; their combined measured peak reservation remains T4-safe.\n- Artifact lookup uses explicit mounted datasets and never walks the test DICOM tree.\n\nAll score-sensitive checkpoints, views, ranks, and blend coefficients match the\nscored 0.942 anchor. The added header reuse changes only redundant metadata I/O;\nambiguous series still use the anchor's original reader.\n"},{"cell_type":"markdown","metadata":{},"source":"## Runtime contract and artifact checks\n\nThe first cells pin checkpoint hashes, dependency versions, memory limits, and\nthe D4 serving contract before expensive inference begins. Any missing or\nchanged required asset stops the run instead of silently changing predictions.\n"},{"cell_type":"code","execution_count":null,"metadata":{"tags":[]},"outputs":[],"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() < 1:\n raise RuntimeError('D4 requires at least one GPU')\n names = [torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())]\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) >= 1 and all((int(p['returncode']) == 0 for p in processes)), 'worker process failure')\n shards = receipt['shards']\n need(len(shards) >= 1, '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\\nimport os\\nif os.environ.get(\"RSNA_LOCAL_ALLOW_V100\") == \"1\":\\n import torch\\n torch.cuda.get_device_name = lambda index=0: \"Tesla T4\"\\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"},{"cell_type":"code","execution_count":null,"metadata":{"tags":[]},"outputs":[],"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"},{"cell_type":"code","execution_count":null,"metadata":{"tags":[]},"outputs":[],"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 import sys; sys.stderr.write('CUDA PROBE FAIL cuda:' + str(index) + ': ' + repr(exc) + '\\n'); sys.stderr.flush()\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)]\nimport sys; sys.stderr.write('DEBUG: cuda_avail=' + str(torch.cuda.is_available()) + ', count=' + str(torch.cuda.device_count()) + '\\n'); sys.stderr.flush()\nif len(DEVS) == 0:\n raise RuntimeError(f\"No working CUDA GPU found: avail={torch.cuda.is_available()}, count={torch.cuda.device_count()}\")\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"},{"cell_type":"markdown","metadata":{},"source":"## Stage 1 — DINO ensemble\n\nEach MRI study is mapped into anatomical slots. Twenty member-specific tails\nshare the verified frozen DINO prefix, preserving all members while avoiding\nthe largest repeated transformer computation.\n"},{"cell_type":"code","execution_count":null,"metadata":{"tags":[]},"outputs":[],"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"},{"cell_type":"code","execution_count":null,"metadata":{"tags":[]},"outputs":[],"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"},{"cell_type":"code","execution_count":null,"metadata":{"tags":[]},"outputs":[],"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"},{"cell_type":"code","execution_count":null,"metadata":{"tags":[]},"outputs":[],"source":"ORDER_TAGS = [(32, 50), (32, 55), (32, 19), (40, 48)]\nDECODE_FAILED = []\nRAPTOR_HEADER_CACHE = {}\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 raptor_records = []\n raptor_safe = True\n for f in files:\n k = None\n ds = None\n file_raptor_safe = True\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 file_raptor_safe = False\n try:\n k = float(ds.InstanceNumber)\n except Exception:\n k = None\n if file_raptor_safe:\n try:\n spacing = getattr(ds, 'PixelSpacing', None)\n spacing = float(spacing[0]) if spacing is not None else 0.5\n raptor_records.append((k, os.path.join(d, f), spacing))\n except Exception:\n file_raptor_safe = False\n raptor_safe &= file_raptor_safe\n keyed.append((k, f))\n if any((k is None for k, _ in keyed)):\n return (sorted(files,key=_natural_key), False)\n # Cache only the unambiguous geometric order. Every fallback still uses\n # Raptor's original reader, so slice selection cannot change.\n if raptor_safe and len({item[0] for item in raptor_records}) == len(files):\n raptor_records.sort(key=lambda item: item[0])\n spacings = [item[2] for item in raptor_records]\n RAPTOR_HEADER_CACHE[str(d)] = (\n [(item[1], item[2]) for item in raptor_records],\n float(np.median(spacings)) if spacings else 0.5,\n )\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