. Version 2 of this\n notebook looked only at the direct children of /kaggle/input, found no label file,\n and fell back to the regex extractor while reporting a clean run, which measured\n the exact artifact the LLM extraction was built to beat.\n\n So this walks a bounded depth instead of listing one level, and prunes the\n competition tree, which holds roughly 730,000 DICOM files and would otherwise make\n the walk cost more than the encoding.\n\n Returns:\n List of Path objects, existing directories only, shallowest first.\n \"\"\"\n out = []\n kin = Path(\"/kaggle/input\")\n if kin.is_dir():\n out.append(kin)\n stack = [(kin, 0)]\n while stack:\n d, depth = stack.pop()\n if depth >= 5:\n continue\n try:\n children = sorted(p for p in d.iterdir() if p.is_dir())\n except OSError:\n continue\n for c in children:\n # Never descend into the DICOM corpus or a git/cache tree.\n if c.name in (\"competitions\", \"train_series\", \"test_series\",\n \".git\", \"__pycache__\"):\n continue\n out.append(c)\n stack.append((c, depth + 1))\n out.append(Path(\"/mnt/data/Github/Kaggle/Competitions\"\n \"/rsna_knee_abnormality_detection/data/interim\"))\n out.append(Path(\"data/interim\"))\n seen, uniq = set(), []\n for d in out:\n if str(d) not in seen and d.is_dir():\n seen.add(str(d))\n uniq.append(d)\n return uniq\n\n\ndef _find_label_file(patterns):\n \"\"\"Find the newest file matching any of the given glob patterns.\n\n Args:\n patterns: Glob patterns, tried in order across every search directory.\n\n Returns:\n A Path, or None when nothing matches.\n \"\"\"\n hits = []\n for d in _label_search_dirs():\n for pat in patterns:\n try:\n hits.extend(sorted(d.glob(pat)))\n except OSError:\n continue\n if not hits:\n return None\n return sorted(hits, key=lambda p: (p.name, str(p)))[-1]\n\n\ndef _read_label_table(path):\n \"\"\"Read a label table and keep only the id column and the twelve findings.\n\n Args:\n path: Parquet or CSV path.\n\n Returns:\n DataFrame indexed by StudyInstanceUID with the twelve label columns as\n floats, or None when the file cannot be read or lacks the columns.\n \"\"\"\n try:\n df = pd.read_parquet(path) if path.suffix == \".parquet\" else pd.read_csv(path)\n except Exception as exc:\n print(\"could not read\", path, \":\", exc)\n return None\n if \"StudyInstanceUID\" not in df.columns or not set(LABELS).issubset(df.columns):\n print(\"label file\", path.name, \"is missing required columns; ignored\")\n return None\n out = df[[\"StudyInstanceUID\"] + LABELS].copy()\n out[\"StudyInstanceUID\"] = out[\"StudyInstanceUID\"].astype(str)\n out = out.drop_duplicates(\"StudyInstanceUID\").set_index(\"StudyInstanceUID\")\n return out[LABELS].astype(float).clip(0.0, 1.0)\n\n\ntrain_ids = train[\"StudyInstanceUID\"].astype(str).tolist()\nreport_col = \"Report\" if \"Report\" in train.columns else None\n\n# ---- 1. Always compute the rule labels; they are the floor and the fallback ----\nrule_df = None\nif LABEL_SOURCE in (\"auto\", \"rule_file\"):\n p = _find_label_file(RULE_LABEL_PATTERNS)\n if p is not None:\n rule_df = _read_label_table(p)\n if rule_df is not None:\n print(\"rule labels from file :\", p.name, \"|\", len(rule_df), \"studies\")\nif rule_df is None:\n if report_col is None:\n raise KeyError(\"train.csv has no Report column and no label file was found\")\n t0 = time.time()\n rule_df = pd.DataFrame([extract_labels(r) for r in train[report_col]],\n index=pd.Index(train_ids, name=\"StudyInstanceUID\"))\n rule_df = rule_df[LABELS].astype(float)\n print(\"rule labels extracted inline: {} reports in {:.1f}s\".format(\n len(rule_df), time.time() - t0))\n\nY_soft = rule_df.reindex(train_ids).astype(float)\nY_soft = Y_soft.fillna(0.0)\nLABEL_PROVENANCE = \"rule\"\nn_llm = 0\n\n# ---- 2. Overwrite with LLM soft labels wherever they exist --------------------\nif LABEL_SOURCE in (\"auto\", \"llm\"):\n p = _find_label_file(LLM_LABEL_PATTERNS)\n if p is not None:\n llm = _read_label_table(p)\n if llm is not None:\n common = [s for s in train_ids if s in llm.index]\n if common:\n Y_soft.loc[common, LABELS] = llm.loc[common, LABELS].values\n n_llm = len(common)\n LABEL_PROVENANCE = \"llm+rule\" if n_llm < len(train_ids) else \"llm\"\n print(\"LLM labels from file :\", p.name, \"|\", n_llm,\n \"of\", len(train_ids), \"studies overwritten\")\n elif LABEL_SOURCE == \"llm\":\n print(\"LABEL_SOURCE='llm' but no LLM label file is mounted; using rule labels\")\n\n# ---- 2b. Fail closed when a declared label dataset did not arrive -------------\n# Falling back to the regex extractor is the right behaviour when no label dataset was\n# ever declared. It is the WRONG behaviour when one was declared and did not mount:\n# the run then measures the artifact the extraction exists to beat, and reports a clean\n# result while doing it. Version 2 of this notebook did exactly that. A guard that\n# treats \"the good input is missing\" as permission to continue is fail-open.\nif LABEL_DATASET_SOURCES and LABEL_PROVENANCE not in (\"llm\", \"llm+rule\"):\n _listing = []\n _kin = Path(\"/kaggle/input\")\n if _kin.is_dir():\n for _d in _label_search_dirs()[:40]:\n try:\n _listing.append(f\"{_d} -> \"\n + \", \".join(sorted(p.name for p in _d.iterdir())[:6]))\n except OSError:\n continue\n raise RuntimeError(\n \"Declared label dataset(s) \" + \", \".join(LABEL_DATASET_SOURCES)\n + \" but no file matched \" + \" / \".join(LLM_LABEL_PATTERNS)\n + f\", so labels resolved to '{LABEL_PROVENANCE}'. Refusing to train on the \"\n \"fallback labels, because the whole point of this run is the extracted ones. \"\n \"Directories searched:\\n \" + \"\\n \".join(_listing)\n )\n\n# ---- 3. Gold labels are ground truth and override anything extracted ----------\nif N_GOLD:\n gold_vals = (train.loc[gold_mask, [\"StudyInstanceUID\"] + LABELS]\n .set_index(train.loc[gold_mask, \"StudyInstanceUID\"].astype(str)))\n Y_soft.loc[gold_ids, LABELS] = gold_vals[LABELS].astype(float).values\n\nIS_GOLD = pd.Series([s in set(gold_ids) for s in train_ids], index=train_ids)\nSAMPLE_WEIGHT = np.where(IS_GOLD.values, GOLD_WEIGHT, 1.0).astype(np.float32)\n\nprev = pd.DataFrame({\n \"mean_soft_target\": Y_soft.mean().round(4),\n \"positives_at_0.5\": (Y_soft >= 0.5).sum().astype(int),\n \"prevalence_%\": ((Y_soft >= 0.5).mean() * 100).round(1),\n})\nprint()\nprint(\"label source :\", LABEL_SOURCE, \"-> resolved to\", LABEL_PROVENANCE)\nprint(\"gold overrides :\", N_GOLD, \"studies, weighted x{:.0f} in the loss\".format(\n GOLD_WEIGHT))\nprint()\nprint(prev.to_string())"},{"cell_type":"code","execution_count":null,"id":"fde180681990","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"# The gold studies are the only ground truth available and there are 58 of them.\n# What that supports is checking whether the extractor agrees with a radiologist,\n# per label. It does not support ranking two models; the standard error on a\n# per-label AUC at this n is near 0.07.\nif N_GOLD and report_col is not None:\n gold_true = train.loc[gold_mask, LABELS].astype(int)\n pred_gold = (rule_df.reindex(gold_ids)[LABELS].values >= 0.5).astype(int)\n rows = []\n for j, lab in enumerate(LABELS):\n yt = gold_true[lab].values\n yp = pred_gold[:, j]\n tp = int(((yt == 1) & (yp == 1)).sum())\n fp = int(((yt == 0) & (yp == 1)).sum())\n fn = int(((yt == 1) & (yp == 0)).sum())\n rows.append({\n \"label\": lab,\n \"gold_pos\": int(yt.sum()),\n \"extractor_pos\": int(yp.sum()),\n \"agreement\": float((yt == yp).mean()),\n \"precision\": tp / (tp + fp) if (tp + fp) else np.nan,\n \"recall\": tp / (tp + fn) if (tp + fn) else np.nan,\n })\n audit = pd.DataFrame(rows)\n print(\"Rule extractor vs gold labels, n = {} studies\".format(N_GOLD))\n print(audit.round(3).to_string(index=False))\n print()\n print(\"mean agreement {:.4f} | mean precision {:.4f} | mean recall {:.4f}\".format(\n audit[\"agreement\"].mean(), audit[\"precision\"].mean(), audit[\"recall\"].mean()))\n print()\n print(\"Reference, measured off-notebook on the same 58 studies:\")\n print(\" rule extractor agreement 0.7960 precision 0.6802 recall 0.7648\")\n print(\" Claude Opus 5 (low) agreement 0.8233 precision 0.6910 recall 0.8602\")\n print(\" paired delta +0.0273 agreement, 95% CI [+0.0029, +0.0532], McNemar p=0.0204\")\nelse:\n audit = pd.DataFrame(columns=[\"label\", \"agreement\", \"precision\", \"recall\"])\n print(\"no gold labels present in this input; the extractor audit is skipped\")"},{"cell_type":"markdown","id":"01d0bd738929","metadata":{},"source":"4Series selection: five slots, not six
\n\n`train_series.csv` gives three flags per series: `Anatomical_Plane`, `Fluid_Sensitive`\nand `Fat_Suppression`. The first thing to check is whether those last two are two\nflags. They are not. `Fluid_Sensitive` and `Fat_Suppression` are **identical on all\n24,371 rows**, so the corpus carries exactly two contrast classes, 14,010 fluid-sensitive\nseries and 10,361 not. Any design that spends a dimension on \"fluid-sensitive and\nfat-suppressed\" is spending it on a copy.\n\nThe frontier fills six slots, three planes by two contrasts, by scoring the series in a\nplane and taking the best unused one for each contrast. Read that rule carefully: the\nsecond slot in a plane fills whenever the plane has **two or more series**, whatever\ntheir contrast. Measured on the manifest, that happens for 97.3% of studies in Sagittal,\n74.5% in Coronal and 24.8% in Axial, which is where the 4.97 of 6 mean fill comes from.\nIt also means that in 237 of the 1,094 studies where the Axial second slot fills, it\nfills with a series of the *same* contrast as the first. The slot's name is not what is\nin it.\n\nDefining the slots by contrast instead, and refusing to fill a slot with the wrong\ncontrast, gives these fill rates over the 4,407 training studies:\n\n| Slot | Studies with a genuine series | Fill |\n|---|---|---|\n| Axial fluid-sensitive | 4,407 | 100.0% |\n| Sagittal non-fluid | 4,266 | 96.8% |\n| Coronal fluid-sensitive | 4,248 | 96.4% |\n| Sagittal fluid-sensitive | 4,150 | 94.2% |\n| Coronal non-fluid | 3,406 | 77.3% |\n| **Axial non-fluid** | **857** | **19.4%** |\n\nThe last row is the decision. An Axial non-fluid slot is empty for four studies in five,\nso a sixth of the encoding budget buys a feature that exists for 19.4% of the corpus and\nis a padded zero for the rest. That budget is worth more as slices in the slots that\nalways fill. Five slots it is, with a mean genuine fill of 4.65 of 5, or 92.9% per slot,\nagainst the frontier's 82.8%.\n\nThe slice budget is then weighted by what each view reads. Sagittal carries the ACL, both\nmeniscal horns, the patellofemoral cartilage and the popliteal fossa, so it takes twice\nwhat Axial takes. Coronal carries the meniscal bodies, the MCL and the medial and lateral\ncompartments. Axial carries the patellofemoral joint, synovium and the suprapatellar\nrecess. The numbers are in the config cell and the expected slices per study is printed\nfrom the manifest, not assumed."},{"cell_type":"code","execution_count":null,"id":"1804cd446b55","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"PLANES = [\"Sagittal\", \"Coronal\", \"Axial\"]\n\n\ndef normalise_manifest(df):\n \"\"\"Coerce a series manifest into the columns the slot builder needs.\n\n Args:\n df: A raw train_series or test_series frame.\n\n Returns:\n A copy with string study/series ids, a title-cased plane and an integer\n fluid flag. Empty in, empty out.\n \"\"\"\n out = df.copy()\n for c in SERIES_COLS:\n if c not in out.columns:\n out[c] = np.nan\n out[\"StudyInstanceUID\"] = out[\"StudyInstanceUID\"].astype(str)\n out[\"SeriesInstanceUID\"] = out[\"SeriesInstanceUID\"].astype(str)\n out[\"plane\"] = out[\"Anatomical_Plane\"].astype(str).str.strip().str.title()\n out[\"fluid\"] = pd.to_numeric(out[\"Fluid_Sensitive\"], errors=\"coerce\") \\\n .fillna(0).astype(int)\n return out\n\n\ntr_man = normalise_manifest(train_series)\nte_man = normalise_manifest(test_series)\n\n# The flag check comes first, because the whole six-slot design downstream rests on\n# it. Fluid_Sensitive and Fat_Suppression are one column wearing two names.\nif len(tr_man) and \"Fat_Suppression\" in train_series.columns:\n fs = pd.to_numeric(train_series[\"Fluid_Sensitive\"], errors=\"coerce\")\n fat = pd.to_numeric(train_series[\"Fat_Suppression\"], errors=\"coerce\")\n n_disagree = int((fs != fat).sum())\n print(\"Fluid_Sensitive vs Fat_Suppression over {:,} series: {} rows disagree\"\n .format(len(train_series), n_disagree))\n print(\" -> {} contrast classes, not four\".format(2 if n_disagree == 0 else 4))\n print(\" fluid-sensitive series {:,} | non-fluid {:,}\".format(\n int((fs == 1).sum()), int((fs == 0).sum())))\n print()\n\n\ndef slot_fill_table(man):\n \"\"\"Measure how often each plane-by-contrast slot has a genuine series.\n\n Args:\n man: A normalised manifest.\n\n Returns:\n DataFrame with one row per candidate slot, sorted by fill rate.\n \"\"\"\n n = man[\"StudyInstanceUID\"].nunique()\n rows = []\n for plane in PLANES:\n for f in (1, 0):\n sub = man[(man[\"plane\"] == plane) & (man[\"fluid\"] == f)]\n have = sub[\"StudyInstanceUID\"].nunique()\n rows.append({\n \"slot\": \"{}_{}\".format(plane, \"Fluid\" if f else \"Structural\"),\n \"series\": len(sub),\n \"studies\": have,\n \"fill\": have / max(1, n),\n \"kept\": \"{}_{}\".format(plane, \"Fluid\" if f else \"Structural\")\n in SLOT_NAMES,\n })\n return pd.DataFrame(rows).sort_values(\"fill\", ascending=False)\n\n\nfill = slot_fill_table(tr_man)\nprint(\"Six candidate slots, measured over {:,} training studies\".format(\n tr_man[\"StudyInstanceUID\"].nunique()))\nprint(fill.to_string(index=False, float_format=lambda v: \"{:.4f}\".format(v)))\nprint()\n\n# The frontier's rule fills a plane's second slot whenever the plane holds two or\n# more series, whatever contrast they are. Reproduce that so the comparison is a\n# measurement rather than a claim.\ncnt = (tr_man.groupby([\"StudyInstanceUID\", \"plane\"]).size().unstack(fill_value=0)\n .reindex(columns=PLANES, fill_value=0))\nn_studies_tr = max(1, len(cnt))\nrival_fill = 3.0 + sum((cnt[p] >= 2).mean() for p in PLANES)\nprint(\"frontier's six-slot rule, second slot per plane fills when the plane has >=2 series:\")\nfor p in PLANES:\n print(\" {:9s} {:5.1f}% of studies\".format(p, 100.0 * (cnt[p] >= 2).mean()))\nax_two = set(cnt.index[cnt[\"Axial\"] >= 2])\nax_true = set(tr_man.loc[(tr_man[\"plane\"] == \"Axial\") & (tr_man[\"fluid\"] == 0),\n \"StudyInstanceUID\"])\nprint(\" mean slots filled {:.3f} / 6 = {:.1%} per slot\".format(\n rival_fill, rival_fill / 6.0))\nprint(\" of the {} studies whose Axial second slot fills, {} have no genuine non-fluid\"\n \" axial series, so the slot holds a duplicate contrast\".format(\n len(ax_two), len(ax_two - ax_true)))\nprint()\n\nkept = fill[fill[\"kept\"]]\nmean_fill = kept[\"fill\"].sum()\nprint(\"this notebook's {} slots, contrast enforced:\".format(N_SLOTS))\nfor name, (_, _, k) in zip(SLOT_NAMES, SLOT_SPEC):\n row = fill.loc[fill[\"slot\"] == name].iloc[0]\n print(\" {:22s} fill {:6.1%} slice budget {:2d}\".format(name, row[\"fill\"], k))\nprint(\" mean slots filled {:.3f} / {} = {:.1%} per slot\".format(\n mean_fill, N_SLOTS, mean_fill / N_SLOTS))\nexp_slices = sum(fill.loc[fill[\"slot\"] == n, \"fill\"].iloc[0] * k\n for n, (_, _, k) in zip(SLOT_NAMES, SLOT_SPEC))\nprint(\" expected slices encoded per study: {:.1f}\".format(exp_slices))\nprint()\n\n\ndef build_slots(man):\n \"\"\"Assign one series to each contrast-defined slot, per study.\n\n A slot is filled only by a series whose plane and fluid flag both match. A\n slot with no matching series stays empty and is carried as a masked, zero\n embedding rather than being back-filled with the wrong contrast.\n\n Args:\n man: A normalised manifest.\n\n Returns:\n Dict mapping study id to a dict of slot name -> series id.\n \"\"\"\n out = {}\n if not len(man):\n return out\n for sid, rows in man.groupby(\"StudyInstanceUID\", sort=False):\n chosen = {}\n used = set()\n for name, (plane, flag, _) in zip(SLOT_NAMES, SLOT_SPEC):\n part = rows[(rows[\"plane\"] == plane) & (rows[\"fluid\"] == flag)]\n for series_id in part[\"SeriesInstanceUID\"].tolist():\n if series_id not in used:\n chosen[name] = series_id\n used.add(series_id)\n break\n out[str(sid)] = chosen\n return out\n\n\nSLOTS_TRAIN = build_slots(tr_man)\nSLOTS_TEST = build_slots(te_man)\nfilled_tr = np.array([len(SLOTS_TRAIN.get(s, {})) for s in train_ids])\nprint(\"slot assignment : train {} studies, mean {:.3f} slots filled\".format(\n len(SLOTS_TRAIN), filled_tr.mean() if len(filled_tr) else 0.0))\nprint(\" test {} studies\".format(len(SLOTS_TEST)))"},{"cell_type":"code","execution_count":null,"id":"3295c24c4d48","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"# Two panels, stacked, one label order shared, so a slot can be tracked straight\n# down the figure. Upper: how often each candidate slot holds a genuine series.\n# Lower: what each kept slot is given to spend.\norder = fill.sort_values(\"fill\", ascending=True).reset_index(drop=True)\nypos = np.arange(len(order))\ncolours = [PRIMARY if k else NEUTRAL for k in order[\"kept\"]]\n\nfig = plt.figure(figsize=(13.2, 10.8))\ngs = fig.add_gridspec(2, 1, height_ratios=[1.0, 0.85], hspace=0.34)\n\nax0 = fig.add_subplot(gs[0, 0])\nax0.barh(ypos, order[\"fill\"].values, height=0.68, color=colours, zorder=3)\nlabel_bars(ax0, order[\"fill\"].values, ypos, fmt=\"{:.1%}\", pad=0.012)\nax0.set_yticks(ypos)\nax0.set_yticklabels(order[\"slot\"].tolist(), fontsize=12.5, color=INK)\nax0.set_xlim(0, 1.16)\nax0.set_xticks([0.0, 0.25, 0.5, 0.75, 1.0])\nax0.set_xticklabels([\"0%\", \"25%\", \"50%\", \"75%\", \"100%\"])\nax0.set_xlabel(\"share of training studies holding a series of that plane and contrast\")\nstyle(ax0, \"x\")\nax0.spines[\"left\"].set_visible(False)\ndropped = order.loc[~order[\"kept\"], \"slot\"].tolist()\nif dropped:\n ax0.text(1.14, ypos[0], \"dropped\", ha=\"right\", va=\"center\", fontsize=12,\n color=ACCENT_TEXT, fontweight=\"bold\")\n\nax1 = fig.add_subplot(gs[1, 0])\nbudgets = []\nfor name in order[\"slot\"]:\n b = dict(zip(SLOT_NAMES, [k for _, _, k in SLOT_SPEC])).get(name, 0)\n budgets.append(b)\nax1.barh(ypos, budgets, height=0.68,\n color=[PRIMARY if b else NEUTRAL for b in budgets], zorder=3)\nlabel_bars(ax1, budgets, ypos, fmt=\"{:.0f}\", pad=0.14)\nax1.set_yticks(ypos)\nax1.set_yticklabels(order[\"slot\"].tolist(), fontsize=12.5, color=INK)\nax1.set_xlim(0, max(budgets + [1]) * 1.22)\nax1.set_xlabel(\"slices encoded per study from that slot\")\nstyle(ax1, \"x\")\nax1.spines[\"left\"].set_visible(False)\n\nfinish(fig,\n \"An Axial non-fluid slot is empty for four studies in five, so its budget \"\n \"goes to slices instead\",\n detail=\"Upper: measured fill over {:,} training studies. Lower: the slice \"\n \"budget each kept slot receives.\".format(\n tr_man[\"StudyInstanceUID\"].nunique()),\n caption=\"A slot is counted filled only when a series matches both the plane \"\n \"and the contrast. The frontier's rule fills a plane's second slot \"\n \"from any spare series, which is why its reported fill is higher and \"\n \"its Axial second slot holds a duplicate contrast in {} of {} cases.\"\n .format(len(ax_two - ax_true), len(ax_two)))"},{"cell_type":"markdown","id":"fb8a1b07299f","metadata":{},"source":"5Slice order is a geometry problem, not a sort
\n\nThe frontier orders slices by filename. Filenames here are SOP Instance UIDs, which are\nrandom. It then samples 11 of them, reads their headers, sorts *those* by position and\npicks three fractional positions from the sample. So the three slices it encodes are\nthree positions within a random 11-slice subset, and the physical extent they span is\nwhatever that subset happened to cover.\n\nPosition is in the files. `ImageOrientationPatient` gives the two in-plane direction\ncosines; their cross product is the slice normal; the dot product of\n`ImagePositionPatient` with that normal is the slice's signed position along the stack.\nThat is exact, it is invariant to how the scanner numbered the instances, and it is the\nonly ordering that makes \"the 30% slice\" mean the same thing in two different studies.\n\nHeaders are read with `stop_before_pixels=True` and a four-tag allowlist, so no pixel\ndecoder is involved and no transfer syntax can fail the read. The corpus mixes\nuncompressed Explicit VR, Implicit VR, JPEG Lossless and JPEG 2000, and that mix is a\nreal hazard for the pixel path, not for this one. Every series has its headers read up to\na cap; the median series holds 30 slices and the cap is well above it, so ordering is\nexact for almost every series and falls back to an evenly spaced filename subset only in\nthe long tail.\n\nSlices are then drawn at evenly spaced fractional positions across a per-plane window of\nthe ordered stack, and the physical millimetres covered is reported. **Each encoded image\nis a three-channel stack of the decoded slice and its two decoded neighbours**, so\nneighbourhood context costs no extra DICOM reads: every decoded slice appears in up to\nthree images."},{"cell_type":"code","execution_count":null,"id":"d38239ab6a8d","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"GEOM_TAGS = [\"ImagePositionPatient\", \"ImageOrientationPatient\",\n \"SliceLocation\", \"InstanceNumber\", \"Laterality\", \"ImageLaterality\"]\n\n# Counters, so a degraded run is visible in the log rather than silent. They are\n# incremented from worker threads, and `d[k] += 1` is three bytecodes, not one, so\n# the lock is not decoration: an undercounted failure reads as a clean run.\nimport threading\n\nSTATS = {\"series_missing\": 0, \"header_fail\": 0, \"pixel_fail\": 0,\n \"series_truncated\": 0, \"slots_empty\": 0, \"slices_decoded\": 0,\n \"exact_order\": 0, \"fallback_order\": 0,\n \"lat_left\": 0, \"lat_right_mirrored\": 0, \"lat_right_reversed\": 0,\n \"lat_absent\": 0, \"lat_conflict\": 0}\n_STATS_LOCK = threading.Lock()\n\n\ndef bump(key, n=1):\n \"\"\"Increment one diagnostic counter under a lock.\n\n Args:\n key: Counter name.\n n: Amount to add.\n\n Returns:\n None.\n \"\"\"\n with _STATS_LOCK:\n STATS[key] = STATS.get(key, 0) + n\n\n\ndef list_dicom_paths(folder):\n \"\"\"List the .dcm files in one series directory.\n\n Args:\n folder: Series directory.\n\n Returns:\n A list of Paths sorted by filename, empty when the directory is missing\n or unreadable. Filename order is SOP UID order here, which is arbitrary;\n it is used only to take a deterministic subset, never as slice order.\n \"\"\"\n try:\n return sorted((Path(e.path) for e in os.scandir(folder)\n if e.is_file() and e.name.lower().endswith(\".dcm\")),\n key=lambda p: p.name)\n except Exception:\n return []\n\n\ndef projected_position(ds, fallback):\n \"\"\"Signed position of a slice along its own stack normal, in millimetres.\n\n The two in-plane direction cosines in ImageOrientationPatient span the slice\n plane; their cross product is the slice normal. Projecting\n ImagePositionPatient onto that normal gives a scalar that increases\n monotonically through the stack and is invariant to how the scanner numbered\n the instances. SliceLocation and InstanceNumber are fallbacks only.\n\n Args:\n ds: A pydicom dataset read with stop_before_pixels.\n fallback: Value to return when no geometry tag is usable.\n\n Returns:\n Float position.\n \"\"\"\n try:\n iop = np.asarray(ds.ImageOrientationPatient, dtype=np.float64)\n ipp = np.asarray(ds.ImagePositionPatient, dtype=np.float64)\n if iop.size == 6 and ipp.size == 3:\n normal = np.cross(iop[:3], iop[3:])\n norm = float(np.linalg.norm(normal))\n if norm > 1e-8:\n return float(np.dot(ipp, normal / norm))\n except Exception:\n pass\n for attr in (\"SliceLocation\", \"InstanceNumber\"):\n try:\n v = float(getattr(ds, attr))\n if np.isfinite(v):\n return v\n except Exception:\n pass\n return float(fallback)\n\n\ndef read_laterality(ds):\n \"\"\"Read which knee this slice belongs to, as \"L\", \"R\" or \"\" for unknown.\n\n Two tags carry it and neither is mandatory. `Laterality` is the general one;\n `ImageLaterality` is what some vendors write instead. The corpus contains at\n least the spellings L, R and LEFT, so the value is folded to its first\n character rather than compared whole, and anything that is not L or R is\n treated as unknown rather than guessed at.\n\n Args:\n ds: A pydicom dataset read with the GEOM_TAGS allowlist.\n\n Returns:\n \"L\", \"R\", or \"\" when neither tag is present or the value is unrecognised.\n \"\"\"\n for tag in (\"Laterality\", \"ImageLaterality\"):\n v = getattr(ds, tag, None)\n if v is None:\n continue\n s = str(v).strip().upper()\n if s[:1] in (\"L\", \"R\"):\n return s[:1]\n return \"\"\n\n\ndef resolve_laterality(votes):\n \"\"\"Collapse per-slice laterality readings into one value for the series.\n\n Args:\n votes: Iterable of per-slice values from `read_laterality`.\n\n Returns:\n \"L\", \"R\", or \"\" when the series is unlabelled or self-contradictory. A\n series that claims both sides is not a series whose geometry is\n understood, so it is left alone rather than resolved by majority.\n \"\"\"\n seen = {v for v in votes if v}\n if len(seen) == 1:\n return seen.pop()\n if len(seen) > 1:\n bump(\"lat_conflict\")\n return \"\"\n\n\ndef order_series(folder):\n \"\"\"Order one series' slices by projected physical position.\n\n Headers are read with stop_before_pixels and a four-tag allowlist, so no\n pixel decoder is involved and none of the four transfer syntaxes in this\n corpus can fail the read. Series longer than the cap are subsampled by\n filename first, which is a uniform draw over positions because filenames are\n SOP UIDs.\n\n Args:\n folder: Series directory.\n\n Returns:\n Tuple of (ordered paths, ordered positions, number of files on disk,\n whether every file on disk was ordered, series laterality as \"L\", \"R\"\n or \"\").\n \"\"\"\n paths = list_dicom_paths(folder)\n n_files = len(paths)\n if n_files == 0:\n bump(\"series_missing\")\n return [], np.zeros(0), 0, False, \"\"\n\n exact = n_files <= MAX_HEADER_READS_PER_SERIES\n if not exact:\n bump(\"series_truncated\")\n idx = np.linspace(0, n_files - 1, MAX_HEADER_READS_PER_SERIES)\n idx = np.unique(np.round(idx).astype(int))\n paths = [paths[i] for i in idx]\n\n positioned, lat_votes = [], []\n for i, p in enumerate(paths):\n try:\n ds = pydicom.dcmread(str(p), stop_before_pixels=True,\n specific_tags=GEOM_TAGS, force=True)\n positioned.append((projected_position(ds, i), p))\n lat_votes.append(read_laterality(ds))\n except Exception:\n bump(\"header_fail\")\n positioned.append((float(i), p))\n positioned.sort(key=lambda t: t[0])\n bump(\"exact_order\" if exact else \"fallback_order\")\n return ([t[1] for t in positioned],\n np.asarray([t[0] for t in positioned], dtype=np.float64),\n n_files, exact, resolve_laterality(lat_votes))\n\n\ndef pick_indices(n, k, lo, hi):\n \"\"\"Choose k evenly spaced indices across a fractional window of n slices.\n\n Args:\n n: Number of ordered slices available.\n k: How many to take.\n lo: Lower fractional bound of the window, in [0, 1].\n hi: Upper fractional bound.\n\n Returns:\n A sorted array of unique integer indices, shorter than k when n is small.\n \"\"\"\n if n <= 0 or k <= 0:\n return np.zeros(0, dtype=int)\n if n <= k:\n return np.arange(n)\n fracs = np.linspace(lo, hi, k)\n idx = np.round(fracs * (n - 1)).astype(int)\n return np.unique(np.clip(idx, 0, n - 1))"},{"cell_type":"markdown","id":"d9daf8507fd5","metadata":{},"source":"6Preprocessing: the window belongs to the series
\n\nPixels are 12-bit and `RescaleSlope`/`RescaleIntercept` are applied first. Then the\nquestion is what to normalise against, and the EDA already answered it: intensity\ndistributions differ sharply from series to series, so a global window is wrong.\n\nA per-*slice* window, which is what the frontier uses, is wrong in the other direction.\nIt rescales every slice to its own 1st and 99th percentile, which means a slice through a\nlarge effusion and a slice through dry bone come out with the same dynamic range. The\nbrightness of fluid on a fluid-sensitive sequence is the finding. Normalising it away\nper slice destroys exactly the signal that `Effusion`, `Synovitis` and `Baker's` are\nmade of, and it also gives the three channels of one 2.5D image three different windows,\nwhich paints colour fringes on every anatomical edge.\n\nSo the percentile window is computed once **per series**, from the pooled pixels of the\nslices that series contributes, and applied unchanged to all of them. The body bounding\nbox is likewise computed once per series from the union of its slices, so the crop does\nnot jitter between neighbouring slices.\n\nOne thing the crop does *not* do here is buy resolution. On every series available\noffline the knee fills the frame: the tissue mask reaches the image edge at every\nthreshold from 0.03 to 0.20, and the bounding box keeps 98 to 100% of the frame. These\nacquisitions are already coned tightly to the joint, so the effective pitch stays at the\nfull 150 mm over the input size and there is no free magnification to collect. The crop\nis kept as a guard for the series that are framed loosely, not as a lever. Whatever it\nachieves on the full corpus is measured and printed after encoding rather than assumed\nhere."},{"cell_type":"markdown","id":"1d02bda693f3","metadata":{},"source":"### 6b. Which knee is this, and why four labels depend on the answer\n\nFour of the twelve targets name a side: `Medial Meniscus`, `Lateral Meniscus`,\n`Medial OA` and `Lateral OA`. Medial and lateral are defined against the midline of the\nbody, not against the image. Which side of the frame the medial compartment lands on\ntherefore depends on which knee was scanned, and that is a fact about the patient rather\nthan about the anatomy the label describes.\n\nThe EDA read the `Laterality` tag across the studies it sampled and found the corpus\nmixes sides: 96 left, 84 right, 5 spelled `LEFT`, and 162 with the tag absent. So close\nto a quarter of studies are mirror images of the rest, and a third of the metric is\nbeing asked to learn a distinction from an axis the model has no way to observe. This is\nnot a subtle modelling choice. It is a third of the score sitting on a coin flip.\n\nThe correction is not one operation, because the mirror falls on a different axis in\neach plane:\n\n| Plane | Medial-lateral direction | Correction |\n|---|---|---|\n| Coronal, Axial | in the image plane | flip the last pixel axis |\n| Sagittal | along the slice axis | reverse the stack order, leave pixels alone |\n\nSagittal is the one worth stating carefully. Mirroring a sagittal slice does nothing\nuseful, because each slice is already a section through the joint at one medial-lateral\ndepth. What differs between a left and a right knee is the direction the stack travels\nthrough the joint, so the stack is reversed and the pixels are untouched. The reversal\nhappens before the 2.5D channels are assembled, so each slice still meets its true\nneighbours, and the fractional position handed to the head is inverted with it rather\nthan left running backwards against its own pixels.\n\nStudies with no tag are left exactly as they are. Forty-seven percent of the sample\ncarried no side, and a wrong flip is strictly worse than no flip: it moves a study to\nthe wrong side of an axis instead of leaving it on an unknown one. Those studies keep an\nunresolved side axis and the cost falls on the same four labels as diluted supervision.\nThe run prints how many slots were normalised, how many were left alone, and how many\nseries contradicted themselves across their own slices, so the size of that residual is\na number in the log rather than an assumption here.\n\nOne consequence for the cache. Embeddings are keyed by a tag that now carries a\npreprocessing version, because a cached embedding is the one artifact that cannot tell\nyou which pixels produced it. Reusing the previous cache here would reload right knees\nencoded in their original orientation and report them as a new result."},{"cell_type":"code","execution_count":null,"id":"5b15458209c4","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"def read_slice(path):\n \"\"\"Decode one DICOM slice into a rescaled float array.\n\n RescaleSlope and RescaleIntercept are applied before anything else, and\n MONOCHROME1 is inverted so bright always means high signal. No window is\n applied here: the window belongs to the series, not the slice.\n\n Args:\n path: Path to a .dcm file.\n\n Returns:\n A 2D float32 array, or None when the file cannot be decoded.\n \"\"\"\n try:\n ds = pydicom.dcmread(str(path), force=True)\n arr = ds.pixel_array.astype(np.float32)\n except Exception:\n bump(\"pixel_fail\")\n return None\n try:\n slope = float(getattr(ds, \"RescaleSlope\", 1.0) or 1.0)\n intercept = float(getattr(ds, \"RescaleIntercept\", 0.0) or 0.0)\n arr = arr * slope + intercept\n if str(getattr(ds, \"PhotometricInterpretation\", \"\")).upper() == \"MONOCHROME1\":\n arr = float(np.nanmax(arr)) - arr\n except Exception:\n pass\n if not np.isfinite(arr).any():\n bump(\"pixel_fail\")\n return None\n bump(\"slices_decoded\")\n return arr\n\n\ndef series_window(arrays, lo_pct=1.0, hi_pct=99.5):\n \"\"\"Outlier-resistant intensity window for a series, from its pooled pixels.\n\n This is the correction that matters most in preprocessing. A per-slice\n window rescales a slice through a large effusion and a slice through dry\n bone onto the same range, which deletes the very contrast that Effusion,\n Synovitis and Baker's are made of, and gives the three channels of one 2.5D\n image three different windows. One window per series keeps relative\n brightness intact within the series while still absorbing the sharp\n between-series intensity differences the EDA found.\n\n Args:\n arrays: List of 2D float arrays from one series.\n lo_pct: Lower percentile.\n hi_pct: Upper percentile.\n\n Returns:\n Tuple (low, high) with high strictly greater than low.\n \"\"\"\n pool = []\n for a in arrays:\n flat = a[::3, ::3].ravel()\n flat = flat[np.isfinite(flat)]\n if flat.size:\n pool.append(flat)\n if not pool:\n return 0.0, 1.0\n pool = np.concatenate(pool)\n nz = pool[np.abs(pool) > 1e-8]\n src = nz if nz.size >= 256 else pool\n lo, hi = np.percentile(src, [lo_pct, hi_pct])\n if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo:\n lo, hi = float(np.min(pool)), float(np.max(pool))\n if hi <= lo:\n hi = lo + 1.0\n return float(lo), float(hi)\n\n\ndef series_bbox(arrays, low, high, thresh=0.06, margin=0.06):\n \"\"\"Body bounding box for a whole series, from the union of its slices.\n\n Computed once per series so the crop does not jitter between neighbouring\n slices, which would put the same anatomy in different patch positions in the\n three channels of one image.\n\n Args:\n arrays: List of 2D float arrays from one series.\n low: Series window low.\n high: Series window high.\n thresh: Normalised intensity above which a pixel counts as tissue.\n margin: Fractional margin added around the union box.\n\n Returns:\n Tuple (y0, y1, x0, x1). The full frame when no box can be found.\n \"\"\"\n h, w = arrays[0].shape\n y0, y1, x0, x1 = h, 0, w, 0\n span = max(high - low, 1e-6)\n for a in arrays:\n if a.shape != (h, w):\n return 0, h, 0, w\n m = ((a - low) / span) > thresh\n if m.sum() < 0.01 * h * w:\n continue\n ys, xs = np.where(m)\n y0 = min(y0, int(ys.min())); y1 = max(y1, int(ys.max()) + 1)\n x0 = min(x0, int(xs.min())); x1 = max(x1, int(xs.max()) + 1)\n if y1 <= y0 or x1 <= x0:\n return 0, h, 0, w\n my = max(2, int(margin * (y1 - y0)))\n mx = max(2, int(margin * (x1 - x0)))\n return (max(0, y0 - my), min(h, y1 + my), max(0, x0 - mx), min(w, x1 + mx))\n\n\nCROP_RATIOS = []\n\n\ndef normalise_laterality(planes, plane, lat):\n \"\"\"Map a right knee onto the left-knee convention.\n\n Four of the twelve targets are medial/lateral pairs, and medial and lateral\n are defined against the body midline rather than against the image. On a\n right knee they therefore fall on the opposite side of the frame from a left\n knee, so without this the four side-specific labels are being asked to learn\n from an axis the model cannot observe.\n\n The correction differs by plane because the mirror acts on a different axis:\n\n * Coronal and axial carry the medial-lateral direction in the image plane, so\n one knee is the horizontal mirror of the other and the last axis flips.\n * Sagittal carries it along the *slice* axis. Each slice is unchanged by the\n mirror; what differs is the direction in which the stack traverses the\n joint, so the stack order reverses and the pixels are left alone.\n\n A study with no `Laterality` tag is left untouched. Roughly half the corpus\n is unlabelled, and a wrong flip is worse than no flip: it moves a study to\n the wrong side rather than leaving it on an unknown one.\n\n Args:\n planes: List of normalised 2D slices in through-plane order.\n plane: Anatomical plane of this slot.\n lat: Series laterality, \"L\", \"R\" or \"\".\n\n Returns:\n Tuple of (possibly transformed planes, whether the stack was reversed).\n \"\"\"\n if lat != \"R\":\n bump(\"lat_left\" if lat == \"L\" else \"lat_absent\")\n return planes, False\n if plane in (\"Coronal\", \"Axial\"):\n bump(\"lat_right_mirrored\")\n return [p[:, ::-1] for p in planes], False\n bump(\"lat_right_reversed\")\n return planes[::-1], True\n\n\ndef build_slot_stack(folder, plane, k, size):\n \"\"\"Decode, window, crop and resize one slot into 2.5D image channels.\n\n Every encoded image is the decoded slice plus its two decoded neighbours as\n the three channels, so neighbourhood context costs no extra DICOM reads:\n each decoded slice is reused in up to three images.\n\n Args:\n folder: Series directory.\n plane: Anatomical plane, selecting the sampling window.\n k: How many slices to encode from this slot.\n size: Output side length in pixels.\n\n Returns:\n Tuple of (images uint8 [m, 3, size, size], positions float32 [m],\n millimetres spanned, number of files on disk). m may be 0.\n \"\"\"\n paths, positions, n_files, _, lat = order_series(folder)\n if not paths:\n return np.zeros((0, 3, size, size), np.uint8), np.zeros(0, np.float32), 0.0, 0\n lo, hi = PLANE_WINDOW.get(plane, (0.15, 0.85))\n idx = pick_indices(len(paths), k, lo, hi)\n if idx.size == 0:\n return np.zeros((0, 3, size, size), np.uint8), np.zeros(0, np.float32), 0.0, n_files\n\n arrays, kept = [], []\n for i in idx:\n a = read_slice(paths[int(i)])\n if a is not None:\n arrays.append(a)\n kept.append(int(i))\n if not arrays:\n return np.zeros((0, 3, size, size), np.uint8), np.zeros(0, np.float32), 0.0, n_files\n\n low, high = series_window(arrays)\n y0, y1, x0, x1 = series_bbox(arrays, low, high)\n h, w = arrays[0].shape\n if h * w > 0:\n CROP_RATIOS.append(math.sqrt(max(1, (y1 - y0) * (x1 - x0)) / float(h * w)))\n\n planes_norm = []\n span = max(high - low, 1e-6)\n for a in arrays:\n if a.shape != (h, w):\n a = resize_2d(a, max(h, w))[:h, :w]\n c = a[y0:y1, x0:x1]\n c = np.clip((c - low) / span, 0.0, 1.0)\n side = max(c.shape)\n pad = np.zeros((side, side), np.float32)\n oy, ox = (side - c.shape[0]) // 2, (side - c.shape[1]) // 2\n pad[oy:oy + c.shape[0], ox:ox + c.shape[1]] = c\n planes_norm.append(np.clip(resize_2d(pad, size) * 255.0, 0, 255).astype(np.uint8))\n\n # Section 6b. Applied before the 2.5D channels are assembled, so a reversed\n # sagittal stack still pairs each slice with its true neighbours rather than\n # with the neighbours it had in the un-normalised direction.\n planes_norm, stack_reversed = normalise_laterality(planes_norm, plane, lat)\n\n m = len(planes_norm)\n imgs = np.zeros((m, 3, size, size), np.uint8)\n for j in range(m):\n imgs[j, 0] = planes_norm[max(0, j - 1)]\n imgs[j, 1] = planes_norm[j]\n imgs[j, 2] = planes_norm[min(m - 1, j + 1)]\n\n pos = positions[np.asarray(kept, dtype=int)] if positions.size else np.arange(m)\n span_mm = float(np.abs(positions.max() - positions.min())) if positions.size > 1 else 0.0\n rng = max(1e-6, float(pos.max() - pos.min())) if m > 1 else 1.0\n frac = ((pos - pos.min()) / rng).astype(np.float32) if m > 1 else np.zeros(m, np.float32)\n if stack_reversed:\n # The head reads `frac` as distance along the slot's own axis. Reversing\n # the images without reversing this would hand every reversed study a\n # positional encoding that runs backwards against its own pixels.\n frac = (1.0 - frac[::-1]).astype(np.float32)\n return imgs, frac, span_mm, n_files\n\n\nprint(\"preprocessing ready\")\nprint(\"laterality : right knees mapped onto the left convention, \"\n \"coronal/axial mirrored, sagittal stack reversed, untagged left alone\")\nprint(\"per-series window percentiles: 1.0 / 99.5, pooled over the slices encoded\")\nprint(\"sampling window by plane :\",\n \", \".join(\"{} {:.2f}-{:.2f}\".format(k, v[0], v[1])\n for k, v in PLANE_WINDOW.items()))"},{"cell_type":"markdown","id":"cb63784b1b03","metadata":{},"source":"7Encoding with a frozen DINOv2
\n\nThe backbone loaded back in section 1 is `facebook/dinov2-small` from the Kaggle model\nmount `metaresearch/dinov2/PyTorch/small/1`, read with `local_files_only=True`. Internet\nis off, which a code-competition submission requires anyway.\n\nThe backbone is frozen and never fine-tuned. That is a deliberate choice given 58 gold\nstudies and a report-derived training signal of unknown fidelity: fine-tuning a 22M\nparameter ViT against noisy pseudo-labels mostly teaches it the noise. What a frozen\nbackbone buys instead is that embeddings are computed once, cached, and every head\nexperiment afterwards costs seconds rather than hours.\n\nDINOv2 interpolates its positional grid on the fly, so a non-native input size needs no\nsurgery, and the direction of that interpolation is worth naming. The released checkpoint\nis configured at 518 px, a 37 by 37 grid. A 336 px input interpolates it down to 24 by 24.\nA 126 px input interpolates it down to 9 by 9, discarding 94% of the positional\nresolution the model was trained with. The higher input size is not an exotic setting\nhere, it is the closer one."},{"cell_type":"markdown","id":"459e6fc27a63","metadata":{},"source":"### Runtime projection before the work\n\nThe visible `test.csv` is a placeholder with three rows. At rerun it holds roughly 1,300\nstudies this notebook has never seen. Before any bulk encoding, a short probe times the\nthree phases separately (header listing and ordering, DICOM decode and preprocess, GPU\nforward) and projects each to the rerun test set and to the full training set. The\nprojection is printed first, then acted on.\n\nIf the projection exceeds the budget the pipeline steps down in a fixed order. If the GPU\nis the phase over budget, the input size drops one rung down the ladder, because that is\nthe only knob that moves GPU cost. Otherwise the per-slot slice budget is scaled back,\nand only after that is the training set subsampled. The test set is never subsampled and\nits encoding runs **first**, so a truncated run still has something to predict with."},{"cell_type":"code","execution_count":null,"id":"37e1c06ab2d4","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"from concurrent.futures import ThreadPoolExecutor\n\nSLOT_ORDER = list(zip(SLOT_NAMES, SLOT_SPEC))\n\n\ndef study_stacks(study_id, dcm_root, slots, size):\n \"\"\"Build the 2.5D image stack for every slot of one study.\n\n Slots are decoded in parallel; each slot is an independent series directory,\n so five threads is five concurrent DICOM decodes. Every failure is caught and\n counted rather than raised, and an empty slot returns an empty stack that the\n caller carries as a masked zero.\n\n Args:\n study_id: Study instance UID.\n dcm_root: Directory holding the per-study series directories.\n slots: Mapping study id -> slot name -> series id.\n size: Input side length in pixels.\n\n Returns:\n Dict mapping slot index to (images, fractional positions, span mm,\n files on disk).\n \"\"\"\n chosen = slots.get(str(study_id), {})\n\n def one(args):\n \"\"\"Decode a single slot, returning an empty stack on any failure.\"\"\"\n i, (name, (plane, _flag, k)) = args\n series_id = chosen.get(name)\n if series_id is None or dcm_root is None:\n bump(\"slots_empty\")\n return i, (np.zeros((0, 3, size, size), np.uint8),\n np.zeros(0, np.float32), 0.0, 0)\n folder = Path(dcm_root) / str(study_id) / str(series_id)\n try:\n return i, build_slot_stack(folder, plane, k, size)\n except Exception:\n bump(\"slots_empty\")\n return i, (np.zeros((0, 3, size, size), np.uint8),\n np.zeros(0, np.float32), 0.0, 0)\n\n with ThreadPoolExecutor(max_workers=min(IO_WORKERS, N_SLOTS)) as pool:\n return dict(pool.map(one, list(enumerate(SLOT_ORDER))))\n\n\ndef probe_cost(ids, dcm_root, slots, size, n):\n \"\"\"Time the decode and the GPU forward on a handful of studies.\n\n Args:\n ids: Candidate study ids.\n dcm_root: DICOM root for that split.\n slots: Slot assignment for that split.\n size: Input side length.\n n: How many studies to probe.\n\n Returns:\n Dict of measured per-study seconds, per-study image counts and the GPU\n rate in images per second. Zeros when nothing could be read.\n \"\"\"\n use = [s for s in ids[:max(1, n)]]\n t_cpu = t_gpu = 0.0\n n_img = 0\n for sid in use:\n t0 = time.time()\n stacks = study_stacks(sid, dcm_root, slots, size)\n t_cpu += time.time() - t0\n imgs = [v[0] for v in stacks.values() if v[0].shape[0]]\n if not imgs:\n continue\n batch = np.concatenate(imgs, axis=0)\n n_img += batch.shape[0]\n t1 = time.time()\n embed_images(batch)\n t_gpu += time.time() - t1\n k = max(1, len(use))\n return {\n \"studies\": len(use),\n \"cpu_per_study\": t_cpu / k,\n \"gpu_per_study\": t_gpu / k,\n \"images_per_study\": n_img / k,\n \"gpu_rate\": (n_img / t_gpu) if t_gpu > 1e-6 else 0.0,\n }\n\n\ntest_ids = test[\"StudyInstanceUID\"].astype(str).tolist()\nprobe_root, probe_ids, probe_slots = TEST_DCM, test_ids, SLOTS_TEST\nif probe_root is None or not probe_ids:\n probe_root, probe_ids, probe_slots = TRAIN_DCM, train_ids, SLOTS_TRAIN\n\nPROBE = {\"studies\": 0, \"cpu_per_study\": 0.0, \"gpu_per_study\": 0.0,\n \"images_per_study\": 0.0, \"gpu_rate\": 0.0}\nif CAN_ENCODE and probe_root is not None:\n PROBE = probe_cost(probe_ids, probe_root, probe_slots, IMG_SIZE, PROBE_STUDIES)\n\nprint(\"probe: {} studies at {} px\".format(PROBE[\"studies\"], IMG_SIZE))\nprint(\" decode + preprocess {:.2f} s/study\".format(PROBE[\"cpu_per_study\"]))\nprint(\" GPU forward {:.2f} s/study ({:.0f} images/s)\".format(\n PROBE[\"gpu_per_study\"], PROBE[\"gpu_rate\"]))\nprint(\" images encoded {:.1f} per study\".format(PROBE[\"images_per_study\"]))\nprint()\n\nper_study = PROBE[\"cpu_per_study\"] + PROBE[\"gpu_per_study\"]\nN_TRAIN_USE = len(train_ids)\nSLICE_SCALE = 1.0\nnotes = []\n\ndef _projected_per_study():\n \"\"\"Seconds per study under the current input size and slice scale.\n\n Returns:\n Float seconds. Zero when the probe measured nothing.\n \"\"\"\n return (PROBE[\"cpu_per_study\"] + PROBE[\"gpu_per_study\"]) * SLICE_SCALE\n\n\nif per_study > 0:\n for _attempt in range(6):\n per_study = _projected_per_study()\n t_test = per_study * RERUN_TEST_STUDIES\n t_train = per_study * N_TRAIN_USE\n gpu_share = ((PROBE[\"gpu_per_study\"] / (PROBE[\"cpu_per_study\"]\n + PROBE[\"gpu_per_study\"]))\n if per_study else 0.0)\n if t_test <= TEST_ENCODE_BUDGET_S and t_train <= TRAIN_ENCODE_BUDGET_S:\n break\n if gpu_share > 0.5 and IMG_SIZE in SIZE_LADDER \\\n and SIZE_LADDER.index(IMG_SIZE) < len(SIZE_LADDER) - 1:\n old = IMG_SIZE\n IMG_SIZE = SIZE_LADDER[SIZE_LADDER.index(IMG_SIZE) + 1]\n # Token count scales with the square of the input size and attention adds\n # a further quadratic term, so the square is the conservative estimate.\n PROBE[\"gpu_per_study\"] *= (IMG_SIZE / float(old)) ** 2\n notes.append(\"input size {} -> {} px, GPU was {:.0%} of the cost\".format(\n old, IMG_SIZE, gpu_share))\n continue\n if SLICE_SCALE > 0.5:\n SLICE_SCALE = max(0.5, SLICE_SCALE - 0.25)\n notes.append(\"slice budget scaled to {:.0%}\".format(SLICE_SCALE))\n continue\n per_study = _projected_per_study()\n N_TRAIN_USE = max(MIN_TRAIN_STUDIES,\n min(N_TRAIN_USE, int(TRAIN_ENCODE_BUDGET_S / per_study)))\n notes.append(\"training studies capped at {}\".format(N_TRAIN_USE))\n break\n\nif SLICE_SCALE < 1.0:\n SLOT_SPEC = [(p, f, max(3, int(round(k * SLICE_SCALE)))) for p, f, k in SLOT_SPEC]\n MAX_SLICES = max(k for _, _, k in SLOT_SPEC)\n SLOT_ORDER = list(zip(SLOT_NAMES, SLOT_SPEC))\n\nprint(\"projected encode cost at {} px, {:.1f} images per study\".format(\n IMG_SIZE, PROBE[\"images_per_study\"] * SLICE_SCALE))\nprint(\" visible test ({:5d} studies): {:8.0f} s\".format(\n len(test_ids), per_study * len(test_ids)))\nprint(\" rerun test (~{:4d} studies): {:8.0f} s budget {:.0f} s\".format(\n RERUN_TEST_STUDIES, per_study * RERUN_TEST_STUDIES, TEST_ENCODE_BUDGET_S))\nprint(\" train ({:5d} studies): {:8.0f} s budget {:.0f} s\".format(\n N_TRAIN_USE, per_study * N_TRAIN_USE, TRAIN_ENCODE_BUDGET_S))\nprint(\" head + submission : {:8.0f} s budget\".format(HEAD_BUDGET_S))\nprint(\" total against the 9 h kernel : {:8.0f} s of {:.0f} s\".format(\n per_study * (RERUN_TEST_STUDIES + N_TRAIN_USE) + HEAD_BUDGET_S, WALL_BUDGET_S))\nif notes:\n print()\n print(\"downshifts applied, in order:\")\n for n in notes:\n print(\" -\", n)\nelse:\n print()\n print(\"no downshift needed\")\n\n# The ladder has a floor: the test set is never subsampled and the training set\n# never goes below MIN_TRAIN_STUDIES. When the projection is still over budget\n# after the floor is reached, say so here rather than printing numbers that\n# quietly exceed the budget. The encode loop's own wall clock is what actually\n# stops it, and it stops train before test because test runs first.\nover_test = per_study * RERUN_TEST_STUDIES > TEST_ENCODE_BUDGET_S\nover_train = per_study * N_TRAIN_USE > TRAIN_ENCODE_BUDGET_S\nif over_test or over_train:\n print()\n print(\"STILL OVER BUDGET after every downshift ({}{}{}).\".format(\n \"rerun test\" if over_test else \"\",\n \" and \" if over_test and over_train else \"\",\n \"train\" if over_train else \"\"))\n print(\"The encode loop is bounded by its own wall clock and will truncate,\")\n print(\"leaving the remaining studies as masked zeros. Test is encoded first,\")\n print(\"so a truncated run still predicts every test study.\")\n\n# Gold studies go first so they survive any truncation, then a deterministic shuffle.\nrest = [s for s in train_ids if s not in set(gold_ids)]\n_rng = np.random.default_rng(SEED)\n_rng.shuffle(rest)\nTRAIN_ENCODE_IDS = (gold_ids + rest)[:N_TRAIN_USE]\nprint()\nprint(\"studies to encode: {} train (gold first), {} test\".format(\n len(TRAIN_ENCODE_IDS), len(test_ids)))"},{"cell_type":"markdown","id":"c6f076d066ec","metadata":{},"source":"### The cache, and how to promote it\n\nEmbeddings are written to `/kaggle/working` as a float16 memory-mapped array plus a mask\nand an id list, tagged with the input size, the slot layout and the slice budget. A rerun\nwith the same tag reloads instead of recomputing, which is what makes head iteration\ncheap inside one session.\n\nTo split this into a train notebook and an inference notebook, which is how it should end\nup once the design settles:\n\n1. Run this notebook with `SAVE_TRAIN_CACHE = True`. The train embeddings and the fitted\n head weights land in the kernel output.\n2. Publish that output as a Kaggle dataset with\n `kaggle datasets create -p /path/to/output`.\n3. Add the dataset to the inference notebook's `dataset_sources`, set\n `LOAD_TRAIN_CACHE_FROM_DATASET = True`, and the rerun then encodes only the ~1,300\n test studies. That is roughly a fifth of the work, and it moves the training cost out\n of the nine-hour submission window entirely.\n\nThe train cache is deleted before the notebook finishes unless `SAVE_TRAIN_CACHE` is on,\nbecause a 600 MB array in the kernel output slows every commit for no benefit until step\n2 is actually wanted."},{"cell_type":"code","execution_count":null,"id":"0a93c94c360b","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"PIX = {}\nPIXOK = {}\n\n# The pixel cache is what makes fine-tuning affordable, and it is also the one\n# artifact here big enough to fill the working directory and take the whole run\n# with it. Project it before allocating anything: one 2.5D image per slot per\n# study, uint8, for both splits. If it does not fit, the fine-tune is dropped and\n# the frozen path proceeds, which is the degradation that costs least.\nFT_BYTES_PER_STUDY = N_SLOTS * 3 * IMG_SIZE * IMG_SIZE\nif FINETUNE:\n _ft_gb = (len(TRAIN_ENCODE_IDS) + len(test_ids)) * FT_BYTES_PER_STUDY / 1e9\n print(\"pixel cache projected: {:.1f} GB for {} train + {} test studies\".format(\n _ft_gb, len(TRAIN_ENCODE_IDS), len(test_ids)))\n if _ft_gb > FT_DISK_BUDGET_GB:\n FINETUNE = False\n print(\" over the {:.0f} GB budget; fine-tuning disabled, frozen path only\"\n .format(FT_DISK_BUDGET_GB))\n\nSLOT_SIG = \"-\".join(str(k) for _, _, k in SLOT_SPEC)\n# Bumped whenever the pixels handed to the backbone change, which is the only\n# thing a cached embedding cannot tell you about itself. v2 is laterality\n# normalisation (section 6b). Without this bump a rerun would silently reload\n# embeddings encoded from un-normalised right knees and report them as new.\nPREP_VERSION = \"lat2\"\nCACHE_TAG = \"dinos{}_slots{}_{}_{}\".format(IMG_SIZE, SLOT_SIG, SLICE_DIM,\n PREP_VERSION)\n\n\ndef cache_files(split):\n \"\"\"Paths of the four cache artifacts for one split.\n\n Args:\n split: \"train\" or \"test\".\n\n Returns:\n Dict of name -> Path under the working directory.\n \"\"\"\n stem = \"emb_{}_{}\".format(split, CACHE_TAG)\n f = {\n \"emb\": WORK / (stem + \".npy\"),\n \"mask\": WORK / (stem + \"_mask.npy\"),\n \"pos\": WORK / (stem + \"_pos.npy\"),\n \"meta\": WORK / (stem + \"_meta.npz\"),\n \"ids\": WORK / (stem + \"_ids.csv\"),\n }\n if FINETUNE:\n # Pixels, not embeddings. Fine-tuning revisits the same images every epoch\n # and re-decoding them per epoch would make the epoch count a function of\n # I/O rather than of learning. One 2.5D image per slot at uint8 costs\n # N_SLOTS * 3 * IMG_SIZE^2 bytes per study, about 1.7 MB at 336 px.\n f[\"pix\"] = WORK / (stem + \"_pix.npy\")\n f[\"pixok\"] = WORK / (stem + \"_pixok.npy\")\n return f\n\n\ndef load_cached(split, ids):\n \"\"\"Reload a cached split when it exists and covers exactly these ids.\n\n Args:\n split: \"train\" or \"test\".\n ids: The study ids this run wants, in order.\n\n Returns:\n Tuple of (emb, mask, pos, nfiles, used, span) or None.\n \"\"\"\n f = cache_files(split)\n dataset_dir = None\n if split == \"train\" and LOAD_TRAIN_CACHE_FROM_DATASET:\n for d in _label_search_dirs():\n if (d / f[\"emb\"].name).is_file():\n dataset_dir = d\n break\n if dataset_dir is not None:\n f = {k: dataset_dir / v.name for k, v in f.items()}\n if not all(p.is_file() for p in f.values()):\n return None\n try:\n cached_ids = pd.read_csv(f[\"ids\"])[\"StudyInstanceUID\"].astype(str).tolist()\n if cached_ids != list(ids):\n print(\"cache for\", split, \"covers different studies; recomputing\")\n return None\n meta = np.load(f[\"meta\"])\n print(\"reusing cached embeddings for\", split, \"from\", f[\"emb\"].parent)\n if FINETUNE:\n PIX[split] = np.load(f[\"pix\"], mmap_mode=\"r\")\n PIXOK[split] = np.load(f[\"pixok\"])\n return (np.load(f[\"emb\"], mmap_mode=\"r\"), np.load(f[\"mask\"]),\n np.load(f[\"pos\"]), meta[\"nfiles\"], meta[\"used\"], meta[\"span\"])\n except Exception as exc:\n print(\"cache for\", split, \"unreadable:\", exc)\n return None\n\n\ndef encode_split(ids, dcm_root, slots, split, budget_s):\n \"\"\"Encode one split into a cached embedding array.\n\n The encoding is bounded by a wall clock. If the budget runs out the loop\n stops and every remaining study is left as a masked zero, which the head\n handles; a truncated run still produces a submission. Test is always encoded\n before train for exactly this reason.\n\n Args:\n ids: Study ids to encode, in order.\n dcm_root: Directory holding per-study series directories.\n slots: Slot assignment for that split.\n split: \"train\" or \"test\".\n budget_s: Wall-clock seconds allowed.\n\n Returns:\n Tuple of (emb, mask, pos, nfiles, used, span).\n \"\"\"\n n = len(ids)\n hit = load_cached(split, ids)\n if hit is not None:\n return hit\n\n f = cache_files(split)\n emb = np.lib.format.open_memmap(\n f[\"emb\"], mode=\"w+\", dtype=np.float16, shape=(n, N_SLOTS, MAX_SLICES, SLICE_DIM))\n mask = np.zeros((n, N_SLOTS, MAX_SLICES), np.bool_)\n pos = np.zeros((n, N_SLOTS, MAX_SLICES), np.float16)\n nfiles = np.zeros((n, N_SLOTS), np.int32)\n used = np.zeros((n, N_SLOTS), np.int32)\n span = np.zeros((n, N_SLOTS), np.float32)\n\n pix = pixok = None\n if FINETUNE:\n pix = np.lib.format.open_memmap(\n f[\"pix\"], mode=\"w+\", dtype=np.uint8,\n shape=(n, N_SLOTS, 3, IMG_SIZE, IMG_SIZE))\n pixok = np.zeros((n, N_SLOTS), np.bool_)\n print(\"pixel cache for {}: {:.1f} GB at {}\".format(\n split, pix.nbytes / 1e9, f[\"pix\"].name))\n PIX[split] = pix\n PIXOK[split] = pixok\n\n if not CAN_ENCODE or dcm_root is None:\n print(\"encode\", split, \": skipped, the imaging path is unavailable here\")\n emb.flush()\n pd.DataFrame({\"StudyInstanceUID\": ids}).to_csv(f[\"ids\"], index=False)\n np.save(f[\"mask\"], mask); np.save(f[\"pos\"], pos)\n np.savez(f[\"meta\"], nfiles=nfiles, used=used, span=span)\n if pix is not None:\n pix.flush()\n np.save(f[\"pixok\"], pixok)\n return emb, mask, pos, nfiles, used, span\n\n t0 = time.time()\n deadline = t0 + budget_s\n done = 0\n report_every = max(1, n // 20)\n for i, sid in enumerate(ids):\n if time.time() > deadline:\n print(\"encode {}: budget of {:.0f}s spent after {} of {} studies\".format(\n split, budget_s, i, n))\n break\n try:\n stacks = study_stacks(sid, dcm_root, slots, IMG_SIZE)\n except Exception:\n bump(\"slots_empty\")\n continue\n batch, index = [], []\n for si, (imgs, frac, sp, nf) in stacks.items():\n nfiles[i, si] = nf\n span[i, si] = sp\n m = min(imgs.shape[0], MAX_SLICES)\n if m == 0:\n continue\n used[i, si] = m\n pos[i, si, :m] = frac[:m].astype(np.float16)\n if pix is not None:\n # The slot's centre image. imgs[c] is already the 2.5D triplet of\n # three consecutive slices, so this is the same input the frozen\n # path sees at that position, kept rather than thrown away after\n # embedding. The pixels are in memory here; storing them costs no\n # extra DICOM read.\n pix[i, si] = imgs[m // 2]\n pixok[i, si] = True\n batch.append(imgs[:m])\n index.extend([(si, j) for j in range(m)])\n if not batch:\n continue\n try:\n vecs = embed_images(np.concatenate(batch, axis=0))\n except Exception as exc:\n print(\"embed failed on study\", i, \":\", type(exc).__name__, exc)\n bump(\"pixel_fail\")\n continue\n for (si, j), v in zip(index, vecs):\n emb[i, si, j] = v.astype(np.float16)\n mask[i, si, j] = True\n done += 1\n if (i + 1) % report_every == 0:\n rate = (i + 1) / max(1e-6, time.time() - t0)\n print(\" {} {:5d}/{:5d} {:.2f} studies/s eta {:.0f}s\".format(\n split, i + 1, n, rate, (n - i - 1) / max(rate, 1e-6)))\n\n emb.flush()\n pd.DataFrame({\"StudyInstanceUID\": ids}).to_csv(f[\"ids\"], index=False)\n np.save(f[\"mask\"], mask)\n np.save(f[\"pos\"], pos)\n np.savez(f[\"meta\"], nfiles=nfiles, used=used, span=span)\n if pix is not None:\n pix.flush()\n np.save(f[\"pixok\"], pixok)\n print(\" pixel cache: {} of {} studies carry at least one slot\".format(\n int(pixok.any(axis=1).sum()), n))\n print(\"encode {}: {} of {} studies in {:.0f}s -> {} ({:.0f} MB)\".format(\n split, done, n, time.time() - t0, f[\"emb\"].name,\n f[\"emb\"].stat().st_size / 1e6 if f[\"emb\"].is_file() else 0.0))\n return emb, mask, pos, nfiles, used, span\n\n\n# Test first. A truncated run must still have something to predict with.\nTE = encode_split(test_ids, TEST_DCM, SLOTS_TEST, \"test\", TEST_ENCODE_BUDGET_S)\nTR = encode_split(TRAIN_ENCODE_IDS, TRAIN_DCM, SLOTS_TRAIN, \"train\",\n TRAIN_ENCODE_BUDGET_S)\nemb_te, mask_te, pos_te, nf_te, used_te, span_te = TE\nemb_tr, mask_tr, pos_tr, nf_tr, used_tr, span_tr = TR\ngc.collect()"},{"cell_type":"code","execution_count":null,"id":"da5db53089ef","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"def coverage_report(name, mask, nfiles, used, span, man, ids):\n \"\"\"Print what fraction of each study's volume was actually encoded.\n\n Args:\n name: Split name for the log.\n mask: Boolean array [studies, slots, slices].\n nfiles: Files on disk per selected series.\n used: Slices encoded per selected series.\n span: Millimetres spanned by each selected series.\n man: Normalised manifest for that split.\n ids: Study ids in row order.\n\n Returns:\n None.\n \"\"\"\n n_enc = mask.sum(axis=(1, 2))\n have = n_enc > 0\n if not have.any():\n print(name, \": nothing was encoded\")\n return\n sel_files = nfiles.sum(axis=1)\n sel_used = used.sum(axis=1)\n ok = sel_files > 0\n per_series = np.where(nfiles > 0, used / np.maximum(nfiles, 1), np.nan)\n\n series_per_study = (man.groupby(\"StudyInstanceUID\").size()\n .reindex(ids).fillna(0).values if len(man) else np.zeros(len(ids)))\n mean_len = np.where(used.sum(axis=1) > 0,\n nfiles.sum(axis=1) / np.maximum((nfiles > 0).sum(axis=1), 1), 0.0)\n est_study_slices = series_per_study * mean_len\n\n print(\"{}: {} of {} studies carry at least one encoded slice\".format(\n name, int(have.sum()), len(ids)))\n print(\" slices encoded per study : mean {:.1f}, median {:.0f}, max {}\".format(\n n_enc[have].mean(), np.median(n_enc[have]), int(n_enc.max())))\n if ok.any():\n print(\" share of the SELECTED series : {:.1%}\".format(\n sel_used[ok].sum() / max(1, sel_files[ok].sum())))\n good = est_study_slices > 0\n if good.any():\n print(\" share of the whole study : {:.1%} (estimated from {:.1f} series \"\n \"per study x {:.0f} slices per series)\".format(\n sel_used[good].sum() / max(1.0, est_study_slices[good].sum()),\n series_per_study[good].mean(), mean_len[good].mean()))\n finite = span[span > 0]\n if finite.size:\n print(\" physical extent per series : {:.0f} mm scanned, sampled across \"\n \"the plane window\".format(np.median(finite)))\n slot_use = (mask.sum(axis=2) > 0).mean(axis=0)\n print(\" slots carrying data : \" + \", \".join(\n \"{} {:.0%}\".format(s, v) for s, v in zip(SLOT_NAMES, slot_use)))\n\n\ncoverage_report(\"train\", mask_tr, nf_tr, used_tr, span_tr, tr_man, TRAIN_ENCODE_IDS)\nprint()\ncoverage_report(\"test \", mask_te, nf_te, used_te, span_te, te_man, test_ids)\nprint()\nif CROP_RATIOS:\n r = float(np.median(CROP_RATIOS))\n print(\"median body crop keeps {:.0%} of the frame, so the effective pitch is \"\n \"{:.3f} mm/px and one patch token covers {:.2f} mm\".format(\n r, FOV_MM * r / IMG_SIZE, FOV_MM * r * PATCH_PX / IMG_SIZE))\nprint()\nprint(\"failure counters:\", \", \".join(\"{} {}\".format(k, v) for k, v in STATS.items()))\nprint(\" series ordered exactly (every file on disk): {} | subsampled: {}\".format(\n STATS[\"exact_order\"], STATS[\"fallback_order\"]))\n_lat_seen = (STATS[\"lat_left\"] + STATS[\"lat_right_mirrored\"]\n + STATS[\"lat_right_reversed\"] + STATS[\"lat_absent\"])\n_lat_fixed = STATS[\"lat_right_mirrored\"] + STATS[\"lat_right_reversed\"]\nprint(\" laterality: {} already left, {} right mirrored (coronal/axial), {} right \"\n \"reversed (sagittal), {} unlabelled and left alone, {} self-contradictory\".format(\n STATS[\"lat_left\"], STATS[\"lat_right_mirrored\"],\n STATS[\"lat_right_reversed\"], STATS[\"lat_absent\"], STATS[\"lat_conflict\"]))\nif _lat_seen:\n print(\" {:.1%} of slots were normalised onto the left-knee convention; \"\n \"{:.1%} carried no side and keep an unresolved axis\".format(\n _lat_fixed / _lat_seen, STATS[\"lat_absent\"] / _lat_seen))"},{"cell_type":"markdown","id":"53ab3a03d2b9","metadata":{},"source":"8Head and validation
\n\nTwo heads, fitted on the cached embeddings, reported separately and blended.\n\n**A ridge probe.** Per study, per slot, the mean and the maximum over encoded slices of\nthe 1,152-dimensional slice vector, concatenated across the five slots, reduced by a\ntruncated SVD fitted on the training rows of each fold, then a multi-output `RidgeCV`.\nIt is the control: linear, closed-form, no capacity to invent structure.\n\n**A slice-attention head.** The same cached vectors, but the pooling is learned. Twelve\nqueries, one per finding, attend over the flattened slot-by-slice token set with the\npadding mask applied, so `Medial Meniscus` can weight the medial sagittal slices and\n`PF OA` can weight the axial ones. Fixed epochs, no early stopping on the fold being\nscored, three seeds averaged. A bare linear probe cannot express \"look at this slice\",\nwhich is the whole reason for encoding 43 slices instead of 3.\n\nThe two are blended at a fixed 0.5 by rank average. The full weight curve is printed for\ninformation and deliberately not tuned: choosing a blend weight on twelve labels' worth\nof out-of-fold estimates is how a number that does not survive contact with the\nleaderboard gets manufactured.\n\n**Folds.** `GroupKFold`, grouped by duplicate report text. Forty-nine report texts in\nthis corpus are shared by 183 studies, the largest block holding 37. Any extractor gives\nevery study in such a block an identical target vector, so a block split across folds\nscores the model on a target whose source it has already seen. Note what is *not* used\nhere: `PatientID`. Patients are 1:1 with studies in this corpus, 4,407 of 4,407, so\ngrouping by patient is a no-op, and the duplicate-report grouping is the one that does\nany work. Skipping the patient grouping also means the fold construction reads no DICOM\nheaders at all."},{"cell_type":"code","execution_count":null,"id":"a88c11d2fa0c","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"from sklearn.model_selection import GroupKFold\nfrom sklearn.metrics import roc_auc_score\n\n# Patients are 1:1 with studies in this corpus, 4,407 of 4,407, so a PatientID\n# grouping is a no-op and reading DICOM PatientID to build it would be pure cost.\n# The grouping that does work is duplicate report text: 49 texts are shared by 183\n# studies, the largest block holding 37, and any extractor gives every study in a\n# block the same twelve targets. A block split across folds scores the model on a\n# target whose source it has already seen.\nreport_by_study = {}\nif report_col is not None:\n for _sid, _txt in zip(train[\"StudyInstanceUID\"].astype(str), train[report_col]):\n report_by_study[_sid] = _txt.strip() if isinstance(_txt, str) else \"\"\n\nfold_ids = list(TRAIN_ENCODE_IDS)\ngroup_of = {}\nnext_group = 0\ntext_group = {}\nfor sid in fold_ids:\n txt = report_by_study.get(sid, \"\")\n if txt:\n if txt not in text_group:\n text_group[txt] = next_group\n next_group += 1\n group_of[sid] = text_group[txt]\n else:\n group_of[sid] = next_group\n next_group += 1\ngroups = np.asarray([group_of[s] for s in fold_ids])\nsizes = pd.Series(groups).value_counts()\nn_blocks = int((sizes > 1).sum())\nprint(\"fold grouping: {} studies -> {} groups\".format(len(fold_ids), len(sizes)))\nprint(\" {} duplicate-report blocks covering {} studies, largest block {}\".format(\n n_blocks, int(sizes[sizes > 1].sum()), int(sizes.iloc[0])))\n\nn_splits = max(2, min(N_FOLDS, len(sizes)))\ngkf = GroupKFold(n_splits=n_splits)\nFOLDS = list(gkf.split(np.zeros(len(fold_ids)), groups=groups))\nfor k, (tr_i, va_i) in enumerate(FOLDS):\n shared = set(groups[tr_i]) & set(groups[va_i])\n assert not shared, \"fold {} leaks {} groups across the split\".format(k, len(shared))\nprint(\" {} folds, no group appears on both sides of any split\".format(len(FOLDS)))"},{"cell_type":"code","execution_count":null,"id":"2f6869ebc459","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"def pooled_features(emb, mask):\n \"\"\"Collapse the per-slice embeddings to one vector per study.\n\n Mean and maximum over the encoded slices of each slot, concatenated across\n slots. The maximum is kept for the same reason it is kept over patch tokens:\n a finding visible on two slices out of twelve is averaged away and is not\n maximised away.\n\n Args:\n emb: float16 array [studies, slots, slices, dim].\n mask: boolean array [studies, slots, slices].\n\n Returns:\n float32 array [studies, slots * 2 * dim].\n \"\"\"\n n = emb.shape[0]\n out = np.zeros((n, N_SLOTS * 2 * SLICE_DIM), np.float32)\n step = max(1, 256)\n for start in range(0, n, step):\n stop = min(n, start + step)\n block = np.asarray(emb[start:stop], dtype=np.float32)\n m = mask[start:stop][..., None].astype(np.float32)\n cnt = np.maximum(m.sum(axis=2), 1.0)\n mean = (block * m).sum(axis=2) / cnt\n neg = np.where(m > 0, block, -1e4)\n mx = neg.max(axis=2)\n mx = np.where(m.sum(axis=2) > 0, mx, 0.0)\n out[start:stop] = np.concatenate([mean, mx], axis=2).reshape(stop - start, -1)\n return out\n\n\ndef manifest_features(ids, man, slots, mask):\n \"\"\"Per-study features that both splits always carry.\n\n Everything here comes from the series manifest, which the hidden test set\n ships, plus the encode mask. Nothing is read from a report and nothing is\n read from a DICOM header, so train and test go through one code path with no\n chance of a block existing on one side only.\n\n Args:\n ids: Study ids in row order.\n man: Normalised manifest.\n slots: Slot assignment.\n mask: Encode mask [studies, slots, slices].\n\n Returns:\n Tuple of (float32 array [studies, n_features], feature names).\n \"\"\"\n by_study = {s: g for s, g in man.groupby(\"StudyInstanceUID\")} if len(man) else {}\n rows = []\n for i, sid in enumerate(ids):\n g = by_study.get(sid)\n total = len(g) if g is not None else 0\n counts = [float((g[\"plane\"] == p).sum()) if g is not None else 0.0\n for p in PLANES]\n fluid = float(g[\"fluid\"].mean()) if g is not None and total else 0.0\n present = [1.0 if n in slots.get(sid, {}) else 0.0 for n in SLOT_NAMES]\n enc = (mask[i].sum(axis=1) / np.maximum(\n np.asarray([k for _, _, k in SLOT_SPEC], np.float32), 1.0)).tolist()\n rows.append([math.log1p(total)] + counts + [fluid] + present + enc)\n names = ([\"log_n_series\"] + [\"n_\" + p for p in PLANES] + [\"fluid_frac\"]\n + [\"has_\" + n for n in SLOT_NAMES] + [\"enc_\" + n for n in SLOT_NAMES])\n return np.asarray(rows, np.float32), names\n\n\nenc_rate_tr = float((mask_tr.sum(axis=(1, 2)) > 0).mean()) if len(TRAIN_ENCODE_IDS) else 0.0\nenc_rate_te = float((mask_te.sum(axis=(1, 2)) > 0).mean()) if len(test_ids) else 0.0\nEMB_OK = (enc_rate_tr >= 0.5 and enc_rate_te >= 0.5\n and abs(enc_rate_tr - enc_rate_te) <= 0.25)\nprint(\"studies with embeddings: train {:.1%} | test {:.1%}\".format(\n enc_rate_tr, enc_rate_te))\nif not EMB_OK:\n print(\"coverage is absent or lopsided, so every embedding column is dropped and\")\n print(\"the head falls back to the series manifest, which both sides always have.\")\n\nMETA_TR, META_NAMES = manifest_features(TRAIN_ENCODE_IDS, tr_man, SLOTS_TRAIN, mask_tr)\nMETA_TE, _ = manifest_features(test_ids, te_man, SLOTS_TEST, mask_te)\n\nif EMB_OK:\n t0 = time.time()\n POOL_TR = pooled_features(emb_tr, mask_tr)\n POOL_TE = pooled_features(emb_te, mask_te)\n print(\"pooled features: train {} | test {} | {:.1f}s\".format(\n POOL_TR.shape, POOL_TE.shape, time.time() - t0))\nelse:\n POOL_TR = np.zeros((len(TRAIN_ENCODE_IDS), 0), np.float32)\n POOL_TE = np.zeros((len(test_ids), 0), np.float32)\n\nY = Y_soft.reindex(TRAIN_ENCODE_IDS)[LABELS].astype(np.float32).values\nW = np.asarray([GOLD_WEIGHT if s in set(gold_ids) else 1.0\n for s in TRAIN_ENCODE_IDS], np.float32)\nY_HARD = (Y >= 0.5).astype(int)\nassert Y.shape[0] == POOL_TR.shape[0] == META_TR.shape[0], \\\n \"label rows drifted from feature rows\"\nprint(\"target matrix :\", Y.shape, \"| positives at 0.5:\", int(Y_HARD.sum()))"},{"cell_type":"code","execution_count":null,"id":"02d0bdad932f","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"from sklearn.decomposition import TruncatedSVD\nfrom sklearn.linear_model import RidgeCV\nfrom sklearn.preprocessing import StandardScaler\n\n# The control head. Linear, closed form, no capacity to invent structure. The SVD\n# is refitted inside every fold on the training rows alone, so no validation row\n# contributes to the basis the model is expressed in.\nRIDGE_ALPHAS = np.logspace(0.0, 5.0, 11)\n\n\ndef fit_ridge_fold(x_tr, y_tr, w_tr, x_va, x_te):\n \"\"\"Fit the ridge probe on one fold and predict the validation and test rows.\n\n Args:\n x_tr: Training design matrix.\n y_tr: Soft targets [n, 12].\n w_tr: Per-row weights.\n x_va: Validation design matrix.\n x_te: Test design matrix.\n\n Returns:\n Tuple of (validation predictions, test predictions).\n \"\"\"\n if x_tr.shape[1] == 0:\n return (np.zeros((x_va.shape[0], len(LABELS))),\n np.zeros((x_te.shape[0], len(LABELS))))\n comps = int(min(SVD_COMPONENTS, max(2, min(x_tr.shape) - 1)))\n if x_tr.shape[1] > comps:\n svd = TruncatedSVD(n_components=comps, random_state=SEED)\n a = svd.fit_transform(x_tr)\n b, c = svd.transform(x_va), svd.transform(x_te)\n else:\n a, b, c = x_tr, x_va, x_te\n sc = StandardScaler().fit(a)\n a, b, c = sc.transform(a), sc.transform(b), sc.transform(c)\n model = RidgeCV(alphas=RIDGE_ALPHAS)\n model.fit(a, y_tr, sample_weight=w_tr)\n return model.predict(b), model.predict(c)\n\n\nX_TR = np.hstack([POOL_TR, META_TR]) if POOL_TR.shape[1] else META_TR\nX_TE = np.hstack([POOL_TE, META_TE]) if POOL_TE.shape[1] else META_TE\nassert X_TR.shape[1] == X_TE.shape[1], \"train/test feature width mismatch\"\n\nt0 = time.time()\noof_ridge = np.zeros((len(TRAIN_ENCODE_IDS), len(LABELS)), np.float32)\nte_ridge = np.zeros((len(test_ids), len(LABELS)), np.float32)\nfor k, (tr_i, va_i) in enumerate(FOLDS):\n try:\n p_va, p_te = fit_ridge_fold(X_TR[tr_i], Y[tr_i], W[tr_i], X_TR[va_i], X_TE)\n except Exception as exc:\n print(\"ridge fold\", k, \"failed:\", type(exc).__name__, exc)\n p_va = np.tile(Y[tr_i].mean(axis=0), (len(va_i), 1))\n p_te = np.tile(Y[tr_i].mean(axis=0), (len(test_ids), 1))\n oof_ridge[va_i] = p_va\n te_ridge += p_te / len(FOLDS)\nprint(\"ridge probe: {} folds in {:.1f}s, {} features\".format(\n len(FOLDS), time.time() - t0, X_TR.shape[1]))"},{"cell_type":"code","execution_count":null,"id":"8d959fcc262a","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"# The class statement itself evaluates its base, so on a machine without torch the\n# whole cell would raise NameError before anything could degrade. Binding the base\n# conditionally keeps the cell importable everywhere; HAVE_ATTN below decides\n# whether it is ever instantiated.\n_HeadBase = nn.Module if HAVE_TORCH else object\n\n\nclass SliceAttentionHead(_HeadBase):\n \"\"\"Twelve learned queries pooling over the slot-by-slice token set.\n\n A linear probe on a pooled study vector cannot express \"look at this slice\",\n which is the entire reason for encoding 43 slices rather than 3. One query\n per finding lets Medial Meniscus weight the medial sagittal slices while\n PF OA weights the axial ones, with the padding mask applied so an empty slot\n contributes nothing rather than contributing a zero vector.\n\n Args:\n d_in: Per-slice embedding width.\n n_slots: Number of slots.\n n_meta: Width of the manifest feature block.\n n_labels: Number of findings.\n hidden: Model width.\n heads: Attention heads.\n dropout: Dropout rate.\n \"\"\"\n\n def __init__(self, d_in, n_slots, n_meta, n_labels, hidden=HEAD_HIDDEN,\n heads=4, dropout=HEAD_DROPOUT):\n if not HAVE_TORCH:\n raise RuntimeError(\"the attention head needs torch\")\n super().__init__()\n self.norm_in = nn.LayerNorm(d_in)\n self.proj = nn.Linear(d_in, hidden)\n self.slot_emb = nn.Parameter(torch.zeros(n_slots, hidden))\n self.pos_proj = nn.Linear(1, hidden)\n self.queries = nn.Parameter(torch.randn(n_labels, hidden) * 0.02)\n self.attn = nn.MultiheadAttention(hidden, heads, dropout=dropout,\n batch_first=True)\n self.norm_q = nn.LayerNorm(hidden)\n self.drop = nn.Dropout(dropout)\n self.out_w = nn.Parameter(torch.zeros(n_labels, hidden))\n self.out_b = nn.Parameter(torch.zeros(n_labels))\n self.meta = nn.Linear(n_meta, n_labels) if n_meta else None\n nn.init.normal_(self.out_w, std=0.02)\n\n def forward(self, x, mask, pos, meta):\n \"\"\"Score one batch of studies.\n\n Args:\n x: float tensor [B, slots, slices, d_in].\n mask: bool tensor [B, slots, slices], True where a slice exists.\n pos: float tensor [B, slots, slices], fractional stack position.\n meta: float tensor [B, n_meta].\n\n Returns:\n Logit tensor [B, n_labels].\n \"\"\"\n b, s, k, _ = x.shape\n h = self.proj(self.norm_in(x))\n h = h + self.slot_emb[None, :, None, :]\n h = h + self.pos_proj(pos.unsqueeze(-1))\n h = torch.nn.functional.gelu(h).reshape(b, s * k, -1)\n m = mask.reshape(b, s * k)\n # A study with no encoded slice at all would make every key padded and the\n # attention softmax would return NaN. Let such a study attend to one zero\n # token instead; its prediction then comes from the meta block alone.\n empty = ~m.any(dim=1)\n if empty.any():\n m = m.clone()\n m[empty, 0] = True\n q = self.queries.unsqueeze(0).expand(b, -1, -1)\n pooled, _ = self.attn(q, h, h, key_padding_mask=~m, need_weights=False)\n pooled = self.drop(self.norm_q(pooled + q))\n logits = (pooled * self.out_w[None]).sum(-1) + self.out_b\n if self.meta is not None:\n logits = logits + self.meta(meta)\n return logits\n\n\ndef run_attention_head():\n \"\"\"Fit the attention head across folds and seeds.\n\n Fixed epochs, no early stopping on the fold being scored, because stopping on\n the fold you then report is how an out-of-fold estimate gets inflated.\n\n Returns:\n Tuple of (out-of-fold predictions, test predictions).\n \"\"\"\n oof = np.zeros((len(TRAIN_ENCODE_IDS), len(LABELS)), np.float32)\n tep = np.zeros((len(test_ids), len(LABELS)), np.float32)\n dev = torch.device(DEVICE)\n y_t = torch.from_numpy(Y)\n w_t = torch.from_numpy(W)\n meta_tr_t = torch.from_numpy(META_TR)\n meta_te_t = torch.from_numpy(META_TE).to(dev)\n n_seeds = len(HEAD_SEEDS)\n\n def batch_tensors(source_emb, source_mask, source_pos, idx):\n \"\"\"Gather one batch out of the memory-mapped cache.\"\"\"\n idx = np.sort(np.asarray(idx))\n x = torch.from_numpy(np.asarray(source_emb[idx], dtype=np.float32)).to(dev)\n m = torch.from_numpy(source_mask[idx]).to(dev)\n p = torch.from_numpy(source_pos[idx].astype(np.float32)).to(dev)\n return idx, x, m, p\n\n for k, (tr_i, va_i) in enumerate(FOLDS):\n for seed in HEAD_SEEDS:\n torch.manual_seed(seed + k)\n model = SliceAttentionHead(SLICE_DIM, N_SLOTS, META_TR.shape[1],\n len(LABELS)).to(dev)\n opt = torch.optim.AdamW(model.parameters(), lr=HEAD_LR,\n weight_decay=HEAD_WD)\n steps = max(1, math.ceil(len(tr_i) / 64)) * HEAD_EPOCHS\n sched = torch.optim.lr_scheduler.OneCycleLR(\n opt, max_lr=HEAD_LR, total_steps=steps, pct_start=0.25)\n rng = np.random.default_rng(seed + k)\n model.train()\n for _ep in range(HEAD_EPOCHS):\n order = rng.permutation(tr_i)\n for start in range(0, len(order), 64):\n sel = order[start:start + 64]\n idx, x, m, p = batch_tensors(emb_tr, mask_tr, pos_tr, sel)\n logit = model(x, m, p, meta_tr_t[idx].to(dev))\n loss = torch.nn.functional.binary_cross_entropy_with_logits(\n logit, y_t[idx].to(dev),\n weight=w_t[idx].to(dev).unsqueeze(1))\n opt.zero_grad(set_to_none=True)\n loss.backward()\n torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)\n opt.step()\n sched.step()\n model.eval()\n with torch.no_grad():\n for start in range(0, len(va_i), 128):\n idx, x, m, p = batch_tensors(emb_tr, mask_tr, pos_tr,\n va_i[start:start + 128])\n oof[idx] += torch.sigmoid(\n model(x, m, p, meta_tr_t[idx].to(dev))).cpu().numpy() / n_seeds\n for start in range(0, len(test_ids), 128):\n sel = np.arange(start, min(len(test_ids), start + 128))\n idx, x, m, p = batch_tensors(emb_te, mask_te, pos_te, sel)\n tep[idx] += torch.sigmoid(\n model(x, m, p, meta_te_t[idx])).cpu().numpy() \\\n / (n_seeds * len(FOLDS))\n print(\" attention head: fold {} of {} done\".format(k + 1, len(FOLDS)))\n return oof, tep\n\n\noof_attn = np.zeros_like(oof_ridge)\nte_attn = np.zeros_like(te_ridge)\nHAVE_ATTN = bool(HAVE_TORCH and EMB_OK and len(TRAIN_ENCODE_IDS) > 50)\nif HAVE_ATTN:\n t0 = time.time()\n try:\n oof_attn, te_attn = run_attention_head()\n print(\"attention head: {} folds x {} seeds in {:.1f}s\".format(\n len(FOLDS), len(HEAD_SEEDS), time.time() - t0))\n except Exception as exc:\n print(\"attention head failed, falling back to the ridge probe alone:\",\n type(exc).__name__, exc)\n HAVE_ATTN = False\nelse:\n print(\"attention head skipped: torch {} | embeddings usable {}\".format(\n HAVE_TORCH, EMB_OK))"},{"cell_type":"markdown","id":"8eabb28e7a76","metadata":{},"source":"7b. Changing what the encoder looks with
\n\nSection 7 froze the backbone and gave a reason: 58 gold studies, a report-derived\nsignal of unknown fidelity, and a 22M parameter transformer that would mostly learn the\nnoise. Half of that reason does not survive reading the code above it. The head does not\ntrain on 58 rows. It trains on every encoded study, several thousand of them, carrying\nreport-derived targets, with the 58 gold rows upweighted eightfold in the loss. Fitting\na transformer to thousands of noisy labels is a different proposition from fitting it to\n58 clean ones, and the argument for freezing quietly used the smaller number.\n\nThe other half of the reason stands. A frozen encoder makes embeddings a one-time cost,\nand every head afterwards runs in seconds. That is why the frozen path stays.\n\nWhat a frozen encoder cannot do is change the vocabulary it looks with. Resolution,\nslice count, slot design and pooling all change how much the model looks and how it\nsummarises what it saw; none of them adds a feature the encoder does not already have.\nDINOv2 learned its features from natural images, where nothing resembles what a torn\nmeniscus does to a proton-density sequence. So the ceiling those axes run into is the\nrepresentation, and the only way to test that claim is to move it.\n\n**The trade this section makes is coverage for adaptation.** The frozen path encodes 46\nslices per study and cannot change its features. This path takes one 2.5D image per\nslot, five per study, and opens the last four transformer blocks. Fewer looks, deeper\nones. The two are then rank-blended, so a study is scored both by a shallow model that\nsaw all of it and by a deep model that saw the middle of each slot.\n\nThree restraints, each with a reason:\n\n**Only the trailing blocks move.** Early blocks are generic edge and texture filters.\nThere may not be enough supervision here to improve them and there is certainly enough\nto damage them.\n\n**The encoder learns two orders of magnitude slower than the head.** The head is random\nand has everything to learn; the encoder starts from a good solution and needs only to\nbe nudged off it. One learning rate would either leave the head untrained or destroy the\nencoder inside the first few hundred steps.\n\n**Pixels are cached, not re-read.** Fine-tuning revisits the same images every epoch, and\nre-decoding them per epoch would make the epoch count a function of disk rather than of\nlearning. The cache is written during the encoding pass that already decodes those\npixels, so it costs no additional DICOM read: one 2.5D image per slot as `uint8`, about\n1.7 MB per study at 336 px.\n\nOne fold is held out, not five. Five fine-tunes do not fit the wall clock. That is a\nbudget decision rather than a statistical one and it is named here rather than buried:\nthe fold score below ranks this head against the frozen ones on identical rows, and it\nis not an estimate of the leaderboard. The blend weight is fixed beforehand for the same\nreason the frozen blend weight is. Selecting it on the single fold that measures it\nwould manufacture a number that does not survive the rerun.\n\nIf any of this fails, the run keeps the frozen submission it had already earned."},{"cell_type":"code","execution_count":null,"id":"bd21b89fc888","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"FT_OK = False\nFT_NOTE = \"not attempted\"\noof_ft = np.zeros((len(TRAIN_ENCODE_IDS), len(LABELS)), np.float32)\nte_ft = np.zeros((len(test_ids), len(LABELS)), np.float32)\nft_val_rows = np.zeros(0, dtype=int)\n\n\ndef _macro_auc_rows(y_true, scores):\n \"\"\"Macro AUC over labels that carry both classes on these rows.\n\n Args:\n y_true: Integer array [n, 12].\n scores: Score array [n, 12].\n\n Returns:\n Tuple of (per-label list with nan where undefined, macro mean).\n \"\"\"\n per = []\n for j in range(y_true.shape[1]):\n col = y_true[:, j]\n if col.min() == col.max():\n per.append(float(\"nan\"))\n continue\n per.append(float(roc_auc_score(col, scores[:, j])))\n finite = [v for v in per if v == v]\n return per, (float(np.mean(finite)) if finite else float(\"nan\"))\n\n\ndef open_last_blocks(backbone, n_blocks):\n \"\"\"Freeze the backbone, then reopen its trailing blocks and final norm.\n\n The early blocks of a vision transformer are generic edge and texture\n filters and the late ones carry semantics. There is not obviously enough\n supervision here to improve the early ones and there is certainly enough to\n damage them, so the line is drawn near the top and the encoder's learning\n rate is held two orders below the head's.\n\n Args:\n backbone: A HuggingFace Dinov2Model.\n n_blocks: How many trailing blocks to train.\n\n Returns:\n Tuple of (number of trainable parameters, number of blocks in the model).\n \"\"\"\n for p in backbone.parameters():\n p.requires_grad_(False)\n layers = backbone.encoder.layer\n for blk in layers[max(0, len(layers) - n_blocks):]:\n for p in blk.parameters():\n p.requires_grad_(True)\n for p in backbone.layernorm.parameters():\n p.requires_grad_(True)\n n_train = sum(p.numel() for p in backbone.parameters() if p.requires_grad)\n return n_train, len(layers)\n\n\nclass SlotFineTuner(_HeadBase):\n \"\"\"The backbone plus twelve label queries pooling over the five slots.\n\n One 2.5D image per slot goes through the encoder, and twelve learned queries\n attend over the five resulting slot vectors. An absent slot is masked out\n rather than contributing a zero vector. This is deliberately the same pooling\n idea as the frozen attention head, so that the comparison between them is a\n comparison of frozen against adapted features and not of two architectures.\n\n Args:\n backbone: The DINOv2 model, already opened for partial training.\n d_in: Width of the per-image feature, CLS concatenated with patch mean.\n n_slots: Number of slots.\n n_labels: Number of findings.\n width: Model width after projection.\n heads: Attention heads.\n dropout: Dropout rate.\n \"\"\"\n\n def __init__(self, backbone, d_in, n_slots, n_labels, width=FT_WIDTH,\n heads=4, dropout=FT_DROPOUT):\n if not HAVE_TORCH:\n raise RuntimeError(\"fine-tuning needs torch\")\n super().__init__()\n self.backbone = backbone\n self.proj = nn.Linear(d_in, width)\n self.slot_emb = nn.Parameter(torch.zeros(n_slots, width))\n self.norm = nn.LayerNorm(width)\n self.queries = nn.Parameter(torch.randn(n_labels, width) * 0.02)\n self.attn = nn.MultiheadAttention(width, heads, dropout=dropout,\n batch_first=True)\n self.drop = nn.Dropout(dropout)\n self.out = nn.Linear(width, 1)\n\n def forward(self, x, slot_ok):\n \"\"\"Score one batch of studies.\n\n Args:\n x: Float tensor [B, S, 3, H, W], already normalised.\n slot_ok: Bool tensor [B, S], True where the slot carries an image.\n\n Returns:\n Logit tensor [B, n_labels].\n \"\"\"\n b, s = x.shape[0], x.shape[1]\n h = self.backbone(pixel_values=x.reshape(b * s, *x.shape[2:]),\n **DINO_KW).last_hidden_state\n feat = torch.cat([h[:, 0], h[:, 1:].mean(1)], dim=1).float()\n f = self.proj(feat).reshape(b, s, -1) + self.slot_emb.unsqueeze(0)\n f = self.norm(f)\n q = self.queries.unsqueeze(0).expand(b, -1, -1)\n pooled, _ = self.attn(q, f, f, key_padding_mask=~slot_ok)\n return self.out(self.drop(pooled)).squeeze(-1)\n\n\ndef _ft_batch(split, rows, dev):\n \"\"\"Gather one batch of cached pixels and normalise it for the encoder.\n\n Args:\n split: \"train\" or \"test\".\n rows: Row indices into the cache.\n dev: Torch device.\n\n Returns:\n Tuple of (pixel tensor [B, S, 3, H, W], slot mask [B, S]).\n \"\"\"\n rows = np.sort(np.asarray(rows))\n raw = np.asarray(PIX[split][rows], dtype=np.float32) / 255.0\n ok = PIXOK[split][rows].copy()\n # A study with no slot at all would make every key masked, and attention over\n # an entirely masked key set is a NaN rather than a zero. Give it slot 0,\n # whose pixels are zeros, so it produces a prediction near the prior.\n dead = ~ok.any(axis=1)\n if dead.any():\n ok[dead, 0] = True\n x = torch.from_numpy(raw).to(dev)\n mean = torch.from_numpy(IMAGENET_MEAN).to(dev).unsqueeze(0)\n std = torch.from_numpy(IMAGENET_STD).to(dev).unsqueeze(0)\n x = (x - mean) / std\n return x, torch.from_numpy(ok).to(dev)\n\n\ndef _ft_predict(model, split, n_rows, dev, batch, rows=None):\n \"\"\"Run the fine-tuned model over selected rows of a split.\n\n Rows outside the selection are left at zero rather than predicted. For the\n training split that is deliberate: this model saw four folds of it, so a\n prediction on those rows is a fit, not an estimate, and an array that quietly\n mixed the two would be misread as out-of-fold the first time anyone used it.\n\n Args:\n model: The trained model.\n split: \"train\" or \"test\".\n n_rows: Number of rows in that split.\n dev: Torch device.\n batch: Studies per forward pass.\n rows: Row indices to predict, or None for all of them.\n\n Returns:\n Float array [n_rows, n_labels] of probabilities, zero where not predicted.\n \"\"\"\n model.eval()\n out = np.zeros((n_rows, len(LABELS)), np.float32)\n todo = np.arange(n_rows) if rows is None else np.sort(np.asarray(rows))\n with torch.no_grad():\n for start in range(0, len(todo), batch):\n sel = todo[start:start + batch]\n x, ok = _ft_batch(split, sel, dev)\n with torch.autocast(device_type=\"cuda\", dtype=torch.float16,\n enabled=(DEVICE == \"cuda\")):\n logit = model(x, ok)\n out[sel] = torch.sigmoid(logit.float()).cpu().numpy()\n return out\n\n\ndef run_finetune():\n \"\"\"Fine-tune the trailing blocks on one grouped fold and predict test.\n\n One fold, not five. Five folds of a fine-tune do not fit the wall clock, and\n a fold count chosen to fit a budget rather than to answer a question is worth\n naming rather than hiding. The held-out fold is scored against the same rows\n the frozen blend is scored on, so the two numbers printed here are comparable.\n\n Returns:\n Tuple of (out-of-fold predictions on the held-out rows, test predictions,\n held-out row indices, a one-line note for the log).\n \"\"\"\n dev = torch.device(DEVICE)\n torch.manual_seed(FT_SEED)\n\n tr_i, va_i = FOLDS[FT_VAL_FOLD]\n has_pix = PIXOK[\"train\"].any(axis=1)\n tr_i = np.asarray([i for i in tr_i if has_pix[i]], dtype=int)\n va_i = np.asarray([i for i in va_i if has_pix[i]], dtype=int)\n if len(tr_i) < 50 or len(va_i) < 20:\n return None, None, None, \"too few studies carry cached pixels\"\n\n n_train, n_layer = open_last_blocks(DINO, FT_UNFREEZE)\n d_in = int(getattr(DINO.config, \"hidden_size\", EMBED_DIM)) * 2\n model = SlotFineTuner(DINO, d_in, N_SLOTS, len(LABELS)).to(dev)\n\n head_params = [p for n, p in model.named_parameters()\n if not n.startswith(\"backbone.\") and p.requires_grad]\n enc_params = [p for p in model.backbone.parameters() if p.requires_grad]\n # An empty parameter group raises, and FT_UNFREEZE = 0 is a legitimate way to\n # ask for the head alone as a control arm.\n groups = [{\"params\": head_params, \"lr\": FT_HEAD_LR}]\n if enc_params:\n groups.insert(0, {\"params\": enc_params, \"lr\": FT_ENCODER_LR})\n opt = torch.optim.AdamW(groups, weight_decay=FT_WD)\n # torch.amp.GradScaler is the current spelling and torch.cuda.amp.GradScaler\n # the older one. Kaggle's image has moved between them before, and a run that\n # dies here loses a fine-tune that was otherwise ready to go.\n try:\n scaler = torch.amp.GradScaler(\"cuda\", enabled=(DEVICE == \"cuda\"))\n except (AttributeError, TypeError):\n scaler = torch.cuda.amp.GradScaler(enabled=(DEVICE == \"cuda\"))\n lossf = nn.BCEWithLogitsLoss(reduction=\"none\")\n\n y_t = torch.from_numpy(Y).to(dev)\n w_t = torch.from_numpy(W).to(dev)\n\n print(\"fine-tune: {} of {} blocks open, {:,} trainable backbone params\".format(\n FT_UNFREEZE, n_layer, n_train))\n print(\" train rows {} | held-out rows {} | fold {} of {}\".format(\n len(tr_i), len(va_i), FT_VAL_FOLD, len(FOLDS)))\n\n batch = FT_STUDY_BATCH\n t0 = time.time()\n steps_per_epoch = max(1, len(tr_i) // batch)\n epochs = FT_EPOCHS\n measured = None\n\n for ep in range(epochs):\n model.train()\n order = np.random.RandomState(FT_SEED + ep).permutation(len(tr_i))\n run_loss, seen = 0.0, 0\n for s in range(steps_per_epoch):\n rows = tr_i[order[s * batch:(s + 1) * batch]]\n if len(rows) == 0:\n continue\n x, ok = _ft_batch(\"train\", rows, dev)\n idx = torch.from_numpy(np.sort(rows)).to(dev)\n with torch.autocast(device_type=\"cuda\", dtype=torch.float16,\n enabled=(DEVICE == \"cuda\")):\n logit = model(x, ok)\n loss_el = lossf(logit.float(), y_t[idx])\n loss = (loss_el.mean(dim=1) * w_t[idx]).sum() / w_t[idx].sum()\n opt.zero_grad(set_to_none=True)\n scaler.scale(loss).backward()\n scaler.step(opt)\n scaler.update()\n run_loss += float(loss.detach()) * len(rows)\n seen += len(rows)\n\n if measured is None and s == 9:\n # Ten steps in, the per-step cost is known. Decide how many epochs\n # actually fit rather than discovering at epoch six that they did\n # not, which is how a run ends with no submission.\n per_step = (time.time() - t0) / 10.0\n fit = int(max(1, (FT_BUDGET_S * 0.8) / max(per_step * steps_per_epoch,\n 1e-6)))\n measured = per_step\n if fit < epochs:\n print(\" budget: {:.2f}s/step projects {:.0f}s per epoch; \"\n \"cutting {} epochs to {}\".format(\n per_step, per_step * steps_per_epoch, epochs, fit))\n epochs = fit\n\n if time.time() - t0 > FT_BUDGET_S:\n print(\" budget of {:.0f}s spent after epoch {}\".format(FT_BUDGET_S, ep + 1))\n break\n print(\" epoch {}/{} loss {:.4f} {:.0f}s elapsed\".format(\n ep + 1, epochs, run_loss / max(seen, 1), time.time() - t0))\n if ep + 1 >= epochs:\n break\n\n # Held-out rows only. Predicting the four folds this model trained on would\n # cost a further forward pass over most of the corpus and produce numbers that\n # cannot be compared with anything.\n val = _ft_predict(model, \"train\", len(TRAIN_ENCODE_IDS), dev, batch, rows=va_i)\n tep = _ft_predict(model, \"test\", len(test_ids), dev, batch)\n note = \"{} epochs, {:.0f}s\".format(min(epochs, FT_EPOCHS), time.time() - t0)\n return val, tep, va_i, note\n\n\nif FINETUNE and HAVE_TORCH and CAN_ENCODE and DINO is not None \\\n and \"train\" in PIX and \"test\" in PIX and PIXOK[\"train\"].any():\n try:\n _val, _te, _rows, FT_NOTE = run_finetune()\n if _val is not None:\n oof_ft, te_ft, ft_val_rows = _val, _te, _rows\n FT_OK = True\n except Exception as exc:\n # A failed fine-tune must not cost the submission the frozen path already\n # earned. It is reported and skipped, never allowed to raise.\n FT_NOTE = \"failed: {}: {}\".format(type(exc).__name__, exc)\n print(\"fine-tune failed, keeping the frozen blend only:\", FT_NOTE)\nelse:\n FT_NOTE = \"skipped: fine-tuning needs torch, a backbone and a pixel cache\"\n\nprint(\"fine-tune:\", FT_NOTE)\n\nif FT_OK and len(ft_val_rows):\n # The same rows for every estimate, so the three numbers are comparable. The\n # frozen heads' predictions on these rows are genuinely out of fold: fold\n # FT_VAL_FOLD was a validation fold for them too.\n _yv = Y_HARD[ft_val_rows]\n _, _m_ridge = _macro_auc_rows(_yv, oof_ridge[ft_val_rows])\n _, _m_ft = _macro_auc_rows(_yv, oof_ft[ft_val_rows])\n print(\"held-out fold {}, {} studies\".format(FT_VAL_FOLD, len(ft_val_rows)))\n print(\" frozen ridge {:.4f}\".format(_m_ridge))\n if HAVE_ATTN:\n _, _m_attn = _macro_auc_rows(_yv, oof_attn[ft_val_rows])\n print(\" frozen attention {:.4f}\".format(_m_attn))\n print(\" fine-tuned {:.4f}\".format(_m_ft))\n print(\"Every number here is measured against extracted labels, so all of them \"\n \"carry the same ceiling. This ranks the heads against each other on one \"\n \"fold. It is not an estimate of the leaderboard.\")"},{"cell_type":"markdown","id":"cccd745fd0fe","metadata":{},"source":"### What the out-of-fold numbers do and do not measure\n\nThe headline out-of-fold macro AUC is computed **against the extracted labels**. Both\nsides of that comparison come from the same extractor, so it answers \"can the images\npredict what the report extractor said\" and nothing else. It is a smoke test with a\nceiling set by extraction quality, not an estimate of the leaderboard.\n\nThe second number is macro AUC **on the 58 gold studies**. That is the right target and\nthe wrong sample size. A per-label AUC on 58 studies with 9 to 35 positives carries a\nstandard error near 0.07; the macro average of twelve such estimates is better and still\nnowhere near the resolution needed to separate two models. It is a sanity check on\ndirection, not a ranking tool.\n\nNeither number selects a model. Model ranking in this competition has to come from a\nreport-derived validation set far larger than 58, which is the next thing this pipeline\nneeds."},{"cell_type":"code","execution_count":null,"id":"76542f78fe0a","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"from scipy.stats import rankdata\n\n\ndef rank01(a):\n \"\"\"Rank-transform each column onto [0, 1].\n\n Args:\n a: 2D array of scores.\n\n Returns:\n Array of the same shape with per-column ranks scaled to [0, 1].\n \"\"\"\n out = np.zeros_like(a, dtype=np.float64)\n for j in range(a.shape[1]):\n r = rankdata(a[:, j], method=\"average\")\n out[:, j] = (r - 1.0) / max(1.0, len(r) - 1.0)\n return out\n\n\ndef macro_auc(y_true, scores):\n \"\"\"Macro-average AUC over the twelve labels, skipping degenerate ones.\n\n Args:\n y_true: Integer array [n, 12].\n scores: Score array [n, 12].\n\n Returns:\n Tuple of (per-label list with NaN where undefined, macro average).\n \"\"\"\n per = []\n for j in range(y_true.shape[1]):\n yt = y_true[:, j]\n if len(np.unique(yt)) < 2:\n per.append(np.nan)\n continue\n try:\n per.append(float(roc_auc_score(yt, scores[:, j])))\n except Exception:\n per.append(np.nan)\n vals = [v for v in per if np.isfinite(v)]\n return per, (float(np.mean(vals)) if vals else np.nan)\n\n\nblend_oof = BLEND_W * rank01(oof_ridge) + (1.0 - BLEND_W) * rank01(oof_attn) \\\n if HAVE_ATTN else rank01(oof_ridge)\nblend_test = BLEND_W * rank01(te_ridge) + (1.0 - BLEND_W) * rank01(te_attn) \\\n if HAVE_ATTN else rank01(te_ridge)\n\n# The fine-tuned model joins the TEST blend only. Its out-of-fold coverage is one\n# fold, so folding it into blend_oof would compare a five-fold estimate against a\n# one-fold one and report the mixture as if it were the shipped model. The weight\n# is fixed rather than selected: choosing it on the one fold that measures it is\n# how a number stops surviving contact with the leaderboard.\nfrozen_test = blend_test.copy()\nif FT_OK:\n blend_test = ((1.0 - FT_BLEND_W) * rank01(frozen_test)\n + FT_BLEND_W * rank01(te_ft))\n print(\"test blend: frozen {:.2f} / fine-tuned {:.2f}, ranks not probabilities\"\n .format(1.0 - FT_BLEND_W, FT_BLEND_W))\n print(\"blend_oof below describes the FROZEN heads only; the fine-tuned model \"\n \"is in the submission but not in that out-of-fold number.\")\nelse:\n print(\"test blend: frozen heads only ({})\".format(FT_NOTE))\n\nper_ridge, m_ridge = macro_auc(Y_HARD, oof_ridge)\nper_attn, m_attn = macro_auc(Y_HARD, oof_attn) if HAVE_ATTN else ([np.nan] * 12, np.nan)\nper_blend, m_blend = macro_auc(Y_HARD, blend_oof)\n\nscores = pd.DataFrame({\n \"label\": LABELS,\n \"positives\": Y_HARD.sum(axis=0),\n \"ridge\": per_ridge,\n \"attention\": per_attn,\n \"blend\": per_blend,\n})\nprint(\"Out-of-fold macro AUC against the EXTRACTED labels\")\nprint(\"(both sides come from the same extractor: a smoke test, not a leaderboard estimate)\")\nprint()\nprint(scores.round(4).to_string(index=False))\nprint()\nprint(\"macro ridge {:.4f} | attention {:.4f} | blend {:.4f}\".format(\n m_ridge, m_attn, m_blend))\nprint()\n\n# The weight curve is printed for information and deliberately not used to pick a\n# weight. Choosing a blend weight on twelve labels' worth of out-of-fold estimates\n# is how a number that does not survive contact with the leaderboard is manufactured.\nif HAVE_ATTN:\n curve = []\n for w in (0.0, 0.25, 0.5, 0.75, 1.0):\n _, m = macro_auc(Y_HARD, w * rank01(oof_ridge) + (1 - w) * rank01(oof_attn))\n curve.append((w, m))\n print(\"blend weight curve (ridge share):\",\n \", \".join(\"{:.2f}->{:.4f}\".format(w, m) for w, m in curve))\n print(\"shipped weight is fixed at {:.2f}, not selected from this curve\".format(BLEND_W))\n print()\n\n# The second number: gold studies only. Right target, wrong sample size.\ngold_rows = [i for i, s in enumerate(TRAIN_ENCODE_IDS) if s in set(gold_ids)]\nif len(gold_rows) >= 10 and N_GOLD:\n gold_truth = (train.set_index(train[\"StudyInstanceUID\"].astype(str))\n .loc[[TRAIN_ENCODE_IDS[i] for i in gold_rows], LABELS]\n .astype(int).values)\n _, g_ridge = macro_auc(gold_truth, oof_ridge[gold_rows])\n _, g_blend = macro_auc(gold_truth, blend_oof[gold_rows])\n print(\"Out-of-fold macro AUC on the {} GOLD studies: ridge {:.4f} | blend {:.4f}\"\n .format(len(gold_rows), g_ridge, g_blend))\n print(\"A per-label AUC on this many studies carries a standard error near 0.07.\")\n print(\"It is a sanity check on direction. It cannot rank two models.\")\nelse:\n print(\"too few gold studies in the encoded set for the gold check\")"},{"cell_type":"code","execution_count":null,"id":"66a68f87957a","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"# Two panels, stacked, one label order shared so a finding can be tracked straight\n# down the figure. Upper: where the model beats chance. Lower: how many positives\n# each estimate rests on, because an AUC on 40 positives and an AUC on 2,000 are\n# not the same measurement.\norder = scores.sort_values(\"blend\", ascending=True).reset_index(drop=True)\nypos = np.arange(len(order))\n\nfig = plt.figure(figsize=(13.2, 11.6))\ngs = fig.add_gridspec(2, 1, height_ratios=[1.15, 0.9], hspace=0.32)\n\nax0 = fig.add_subplot(gs[0, 0])\nvals = order[\"blend\"].values.astype(float)\nax0.barh(ypos, np.nan_to_num(vals, nan=0.5), height=0.66, color=PRIMARY, zorder=3)\nlabel_bars(ax0, vals, ypos, fmt=\"{:.3f}\", pad=0.006)\nif HAVE_ATTN:\n ax0.plot(order[\"ridge\"].values.astype(float), ypos, linestyle=\"none\",\n marker=\"D\", markersize=7, color=ACCENT, zorder=5, label=\"ridge probe alone\")\n ax0.legend(loc=\"lower right\", labelcolor=INK_2)\nax0.axvline(0.5, color=AXIS, linewidth=1.4, zorder=2)\n# The chance rule is annotated below the lowest bar, not above the highest: at the\n# top it lands on top of the leading bar and hides the number that matters most.\nax0.text(0.5, -0.95, \" chance\", ha=\"left\", va=\"center\", fontsize=11.5, color=MUTED)\nax0.set_ylim(-1.35, len(order) - 0.4)\nax0.set_yticks(ypos)\nax0.set_yticklabels(order[\"label\"].tolist(), fontsize=12.5, color=INK)\nlo = float(np.nanmin(np.append(vals, 0.5)))\nax0.set_xlim(min(0.45, lo - 0.03), 1.02)\nax0.set_xlabel(\"out-of-fold AUC against the extracted labels\")\nstyle(ax0, \"x\")\nax0.spines[\"left\"].set_visible(False)\n\nax1 = fig.add_subplot(gs[1, 0])\npos = order[\"positives\"].values.astype(float)\nax1.barh(ypos, pos, height=0.66, color=NEUTRAL, zorder=3)\nlabel_bars(ax1, pos, ypos, fmt=\"{:,.0f}\", pad=max(1.0, pos.max() * 0.012))\nax1.set_yticks(ypos)\nax1.set_yticklabels(order[\"label\"].tolist(), fontsize=12.5, color=INK)\nax1.set_xlim(0, max(1.0, pos.max()) * 1.18)\nax1.set_xlabel(\"extracted positives the estimate above rests on\")\nstyle(ax1, \"x\")\nax1.spines[\"left\"].set_visible(False)\n\nfinish(fig,\n \"Out-of-fold AUC per finding, and the evidence each number rests on\",\n detail=\"Blend of the ridge probe and the slice-attention head at a fixed \"\n \"0.5 rank weight. Macro average {:.4f}.\".format(m_blend),\n caption=\"Targets are extractor output, not radiologist labels, so this \"\n \"measures agreement with the extractor and carries its ceiling. \"\n \"Folds are grouped by duplicate report text; no group appears on \"\n \"both sides of a split.\")"},{"cell_type":"markdown","id":"70c43b87f9c1","metadata":{},"source":"9Submission
\n\nColumn order comes from `sample_submission.csv` rather than being assumed. Row identity\ncomes from `test.csv`, so the file covers exactly the studies the grader expects in the\norder it expects them. Row count, column set, finiteness and range are all asserted\nbefore the file is written.\n\nThe degradation path matters more here than in a metadata notebook, because there are\nmany more ways for an imaging pipeline to come up empty. If the DINOv2 weights are not\nmounted, if Torch is missing, if the DICOM directories are absent, or if the encode phase\nruns out of budget, the notebook still writes a valid submission from the series manifest\nalone. A weak submission is a score; an exception is not."},{"cell_type":"code","execution_count":null,"id":"a33c619350d2","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"sub_cols = [\"StudyInstanceUID\"] + LABELS\nif list(sample_sub.columns[:1]) == [\"StudyInstanceUID\"] and \\\n set(LABELS).issubset(sample_sub.columns):\n sub_cols = list(sample_sub.columns)\n\npred = np.clip(np.asarray(blend_test, dtype=float), 0.0, 1.0)\nif not np.isfinite(pred).all():\n print(\"non-finite predictions replaced by the per-label training prior\")\n prior = Y.mean(axis=0)\n bad = ~np.isfinite(pred)\n pred[bad] = np.take(prior, np.where(bad)[1])\n\nsub = pd.DataFrame(pred, columns=LABELS)\nsub.insert(0, \"StudyInstanceUID\", test_ids)\nsub = sub[sub_cols]\n\nassert len(sub) == len(test), \"row count does not match test.csv\"\nassert list(sub.columns) == sub_cols, \"column order does not match the sample submission\"\nassert sub[\"StudyInstanceUID\"].tolist() == test[\"StudyInstanceUID\"].astype(str).tolist(), \\\n \"row identity or order drifted from test.csv\"\nassert np.isfinite(sub[LABELS].values).all(), \"non-finite value in the submission\"\nassert (sub[LABELS].values >= 0).all() and (sub[LABELS].values <= 1).all(), \\\n \"probability out of range\"\n\nout_path = WORK / \"submission.csv\"\nsub.to_csv(out_path, index=False)\nprint(\"wrote\", out_path, \"|\", len(sub), \"rows x\", len(sub.columns), \"columns\")\nprint()\nprint(sub.head().to_string(index=False))\nprint()\nprint(\"per-label mean predicted probability\")\nprint(sub[LABELS].mean().round(4).to_string())\n\n# The train cache is 600 MB and slows every commit until it is actually wanted as a\n# dataset. Delete it unless promotion is on.\nif not SAVE_TRAIN_CACHE:\n removed = 0\n for p in cache_files(\"train\").values():\n try:\n if p.is_file() and p.parent == WORK:\n p.unlink()\n removed += 1\n except Exception:\n pass\n if removed:\n print()\n print(\"removed {} train cache files from the output; set SAVE_TRAIN_CACHE=True\"\n \" to keep them for promotion to a dataset\".format(removed))"},{"cell_type":"markdown","id":"a8fd90e5959b","metadata":{},"source":"10What this is not
\n\nThe backbone is frozen and was pretrained on natural images. DINOv2 features transfer\nwell to medical imaging but they are not a knee model, and nothing in this notebook\nadapts them to MR. Fine-tuning is the obvious next lever and it is deliberately held back\nuntil the label source is settled, because fine-tuning against noisy pseudo-labels\nteaches the noise.\n\nThe training targets are extracted from reports. Whatever the extractor gets wrong is\nbaked into everything downstream, and the audit in section 3 puts the honest ceiling on\nwhat a model trained on them can reach.\n\nThe resolution argument is arithmetic about sampling, and arithmetic is not a leaderboard\nscore. It says the frontier's input cannot represent the finding; it does not by itself\nsay that 336 px converts into AUC. That claim needs a submission, and this notebook has\nnot been scored at the time of writing.\n\nThe next three things worth doing, in the order they pay: replace the extracted labels\nwith the audited LLM extraction across all 4,349 unlabelled studies; build a\nreport-derived validation set large enough to rank two models; then split train and\ninference so the nine-hour budget buys inference only. The recovered time should go into\na larger backbone or more slices, not into a larger input, because section 2 measured\nthat 448 px buys nothing over 336."},{"cell_type":"markdown","id":"1f39ffcd8900","metadata":{},"source":"How this notebook was made
\n\nThis notebook was generated by an agentic system rather than typed by hand. The system is\nClaude Code running a custom multi-agent LLM harness: one agent drafted the pipeline while\nseparate adversarial verifier agents tried to break it and sent each defect back to the\nbuilder script instead of patching the notebook. The verifier agents are the part that\nmatters, because a notebook that has never been run is a draft.\n\nThe source of truth is a Python builder script, `notebooks/build_dino_notebook.py` in the\nworking repository, which emits this `.ipynb` through `nbformat`. Review happens on plain\nPython, and the notebook is regenerated rather than edited. The rule label extractor is\nnot copied into this builder; it is imported from the baseline notebook's builder module,\nso the two notebooks cannot drift apart. Publication uses `kaggle kernels push` and\nsubmission uses the same CLI, as with the companion EDA and baseline notebooks.\n\nThe competition facts this notebook is built on were verified from the Kaggle API and\nfrom the data itself on 2026-08-05, the day the competition opened: the 150 mm field of\nview across four acquisition matrices, the identity of `Fluid_Sensitive` and\n`Fat_Suppression` across all 24,371 series, the six-slot fill rates, the 49 report texts\nshared by 183 studies, and the 1:1 patient-to-study mapping. The slot fill rates, the\nduplicate-report blocks and the resolution arithmetic are all recomputed at run time in\nthe cells above rather than quoted from that check.\n\nThis notebook has no leaderboard score at the time of writing and claims none."},{"cell_type":"code","execution_count":null,"id":"b4cf129fd2e8","metadata":{"_kg_hide-input":true,"jupyter":{"source_hidden":true}},"outputs":[],"source":"import platform\n\nprint(\"python \", platform.python_version())\nfor mod in [\"numpy\", \"pandas\", \"sklearn\", \"scipy\", \"matplotlib\", \"pydicom\",\n \"torch\", \"transformers\", \"cv2\"]:\n try:\n print(\"{:12s}\".format(mod), __import__(mod).__version__)\n except Exception as exc:\n print(\"{:12s} unavailable ({})\".format(mod, type(exc).__name__))\nprint()\nprint(\"input root \", ROOT)\nprint(\"seed \", SEED)\nprint(\"input size \", IMG_SIZE, \"px ->\",\n \"{:.3f} mm/px, {:.2f} mm per token\".format(\n FOV_MM / IMG_SIZE, FOV_MM * PATCH_PX / IMG_SIZE))\nprint(\"slots / budgets \", \", \".join(\n \"{}={}\".format(n, k) for n, (_, _, k) in zip(SLOT_NAMES, SLOT_SPEC)))\nprint(\"label source \", LABEL_SOURCE, \"->\", LABEL_PROVENANCE)\nprint(\"backbone \", DINO_INFO)\nprint(\"cache tag \", CACHE_TAG)\nprint(\"studies encoded \", \"train {} / test {}\".format(\n int((mask_tr.sum(axis=(1, 2)) > 0).sum()), int((mask_te.sum(axis=(1, 2)) > 0).sum())))\nprint(\"slices decoded \", STATS[\"slices_decoded\"])\nprint(\"failures \", \", \".join(\n \"{} {}\".format(k, v) for k, v in STATS.items() if k.endswith(\"fail\")\n or k.endswith(\"missing\") or k == \"slots_empty\"))"}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"mimetype":"text/x-python","name":"python"}},"nbformat":4,"nbformat_minor":5}