{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.11"},"kaggle":{"accelerator":"nvidiaTeslaT4","isGpuEnabled":true,"isInternetEnabled":false,"language":"python","sourceType":"notebook","title":"RSNA EXP-001 fold0 probe GPU","slug":"rsna-exp001-fold0-probe-gpu"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# RSNA EXP-001 fold0 probe: artifact persistence + timing\n\n目的:验证 artifact 持久化链路 + 记录 fold0 真实 wall-clock。\n变更(2026-09-10, 本地干跑验证后):\n1. 修复 duplicate predict_test/plane_oof_auc 块;\n2. 包 torch 依赖类进 if HAS_TORCH: 使本地 --help 可测;\n3. @torch.no_grad 装饰器改为函数内 with 上下文;\n4. 每折保存 test_pred.npy / test_uid.csv / meta.json;\n5. experiment-level config.json + fold_assignment.csv;\n6. --resume-dir 支持跨 session 续训;\n7. UID-aligned ensemble 加载 + 缺失折容错.\n\n命令:python rsna_v3.py --planes sagittal --epochs 3 --folds 5 --only-fold 0 --batch 8 --n-clips 2 --verbose\n","metadata":{}},{"cell_type":"code","source":"# 提交模式:禁网(enable_internet:false),torch 2.2.0+cu118 + nvidia-cu11 依赖全部离线安装\n# 坑1:Kaggle 挂载把文件名中 '+' 去掉(2.2.0cu118=非法 PEP440)→ 复制为合法名\n# 坑2:torch 2.2.0+cu118 的 CUDA 库在 nvidia-*-cu11 依赖包中(不在 torch wheel 内),\n#     只装 torch 会缺 libcudart(v8/v9 实证)→ 必须显式安装全部 13 个 wheel\n# 坑3:/kaggle/working 会被收集为 kernel 输出 → 装完立即删除\nimport subprocess, sys, os, glob, shutil\nwh = sorted(glob.glob('/kaggle/input/**/*.whl', recursive=True))\nprint('挂载 wheel 共', len(wh), '个')\nfor w in wh: print('  ', os.path.basename(w))\nassert len(wh) >= 13, 'FAIL: 离线 wheel 不足(应 13: torch+torchvision+11 nvidia-cu11)'\nfixed = []\nfor w in wh:\n    base = os.path.basename(w)\n    dst = os.path.join('/kaggle/working', base.replace('cu118', '+cu118', 1) if 'cu118' in base else base)\n    shutil.copy(w, dst)\n    fixed.append(dst)\nprint('安装 wheel:', [os.path.basename(f) for f in fixed])\nsubprocess.check_call([sys.executable,\"-m\",\"pip\",\"uninstall\",\"-y\",\"-q\",\"torch\",\"torchvision\",\"torchaudio\"])\n# 显式安装全部 wheel(--no-deps --no-index: 无版本解析/无联网)\nsubprocess.check_call([sys.executable,\"-m\",\"pip\",\"install\",\"-q\",\"--no-deps\",\"--no-index\"] + fixed)\nfor f in fixed: os.remove(f)\nimport numpy, torch, torchvision, sklearn, pandas\nprint(\"torch\", torch.__version__, \"cuda\", torch.version.cuda, \"| numpy\", numpy.__version__)\nassert torch.cuda.is_available()\nprint(\"GPU:\", torch.cuda.get_device_name(0))\n","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# preflight:test DICOM 布局抽样(防训完才暴露 test 读不到,浪费额度)\n# 扫描兼容 1/2/3 层挂载:/kaggle/input/<slug>/、/<slug>/<slug>、/competitions/<slug>;\n# 跳过 train_series/test_series 大目录(内部不可能有 test.csv)\nimport os\nbase='/kaggle/input'\ndef _find(b, depth=0, max_depth=3):\n    if not os.path.isdir(b): return None\n    try: entries = sorted(os.listdir(b))\n    except OSError: return None\n    for e in entries:\n        p = os.path.join(b, e)\n        if not os.path.isdir(p): continue\n        if e in ('train_series', 'test_series'): continue\n        if os.path.isfile(os.path.join(p, 'test.csv')) and os.path.isdir(os.path.join(p, 'test_series')):\n            return p\n        if depth < max_depth - 1:\n            r = _find(p, depth + 1)\n            if r: return r\n    return None\nroot = _find(base)\nif root is None:\n    raise SystemExit('FAIL: 未找到含 test_series+test.csv 的比赛挂载(已扫 /kaggle/input 3 层)')\nprint('root =', root)\nts=os.path.join(root,'test_series'); n_dcm=0\nfor st in sorted(os.listdir(ts))[:3]:\n    sp=os.path.join(ts,st)\n    if not os.path.isdir(sp): continue\n    for se in sorted(os.listdir(sp))[:3]:\n        sdir=os.path.join(sp,se)\n        if not os.path.isdir(sdir): continue\n        k=len([f for f in os.listdir(sdir) if f.lower().endswith('.dcm')])\n        print(' study', st[:14], 'series', se[:14], 'dcm:', k); n_dcm+=k\nprint('preflight:', 'OK' if n_dcm>0 else 'FAIL: test DICOM 为空')\nassert n_dcm>0\n","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import base64, os\nparts = []\nparts.append(\"# -*- coding: utf-8 -*-
"""
RSNA Knee Abnormality Detection — v2(按 Anatomical_Plane 分平面独立建模 + 融合)
================================================================================
相对 baseline(rsna_baseline.py)的核心改动:
- baseline 把 study 内所有平面的 series 粗暴拼成通道;v2 按 Anatomical_Plane
  (Axial / Sagittal / Coronal)各训一个独立 ResNet34,平面内部再做 2.5D clip;
- test 推理时每个平面模型独立预测,最终按 各平面 OOF 宏平均 AUC 加权融合
  (权重可 --fuse weight 用 AUC 加权,或 --fuse mean 简单平均);
- 某 study 缺某平面时,融合只对该 study 实际可用的平面归一化权重。

其余逻辑(软标签填充、GroupKFold、valid 掩码损失、DICOM 预处理)与 baseline 一致。

运行环境:Kaggle Notebook(GPU,挂载比赛数据 + 社区软标签数据集)。
用法:
    !python rsna_v2.py --epochs 3 --batch 16 --n-clips 2 --planes sagittal,coronal
    !python rsna_v2.py --epochs 3 --batch 16 --fuse weight --pseudo-conf 0.3
输出: submission.csv(StudyInstanceUID + 12 列置信分数)
"""
import argparse
import json
import os
import sys
import time
import warnings
from pathlib import Path

import numpy as np
import pandas as pd

try:
    import torch
    import torch.nn as nn
    from torch.utils.data import Dataset, DataLoader
    from torch.optim import AdamW
    from torch.optim.lr_scheduler import CosineAnnealingLR
    HAS_TORCH = True
except ImportError:
    HAS_TORCH = False

try:
    import torchvision.models as tvm
    HAS_TV = True
except ImportError:
    HAS_TV = False

try:
    import pydicom
    HAS_PYDICOM = True
except ImportError:
    HAS_PYDICOM = False

try:
    import rsna_report_labels as RL   # 报告→12 病灶弱标签(与 rsna_v3.py 同目录)
    HAS_RL = True
except ImportError:
    HAS_RL = False

from sklearn.model_selection import GroupKFold
from sklearn.metrics import roc_auc_score

warnings.filterwarnings("ignore")

LABELS = ["ACL", "MCL", "Medial Meniscus", "Lateral Meniscus",
          "Medial OA", "Lateral OA", "PF OA", "Effusion", "Synovitis",
          "Baker's", "Contusion", "Fracture"]
LABELS_EN = ["ACL", "MCL", "MedialMeniscus", "LateralMeniscus",
             "MedialOA", "LateralOA", "PFOA", "Effusion", "Synovitis",
             "Bakers", "Contusion", "Fracture"]  # 列名安全化(写提交用)
PLANES = ["Axial", "Sagittal", "Coronal"]

IMG_SIZE = 224
CLIP = 3          # 每 clip 切片数(prev/center/next)
MAX_SERIES = 4    # 每 study 每个平面最多取的 series 数(v2 按平面取,单平面 series 更少,4 足够)
FOLDS = 5
SEED = 42


def resolve_paths():
    """数据定位顺序:1) /kaggle/input 挂载;2) kagglehub 自动下载;3) 本地 rsna_knee/ 目录。"""
    # 1) Kaggle 挂载(兼容多层挂载:/kaggle/input/<数据名>/ 或 /kaggle/input/<分类>/<数据名>/)
    if os.path.isdir("/kaggle/input"):
        for sub in sorted(os.listdir("/kaggle/input")):
            d = os.path.join("/kaggle/input", sub)
            for cand in (d, os.path.join(d, sub)):  # 处理 Kaggle 双层挂载
                if os.path.exists(os.path.join(cand, "train.csv")):
                    return cand, "/kaggle/working"
            if os.path.isdir(d):  # 再往下一层找(如 /kaggle/input/competitions/<name>/)
                for sub2 in sorted(os.listdir(d)):
                    cand = os.path.join(d, sub2)
                    if os.path.exists(os.path.join(cand, "train.csv")):
                        return cand, "/kaggle/working"
        print("[诊断] /kaggle/input 存在,但没找到含 train.csv 的目录。实际挂载内容如下:", flush=True)
        for sub in sorted(os.listdir("/kaggle/input")):
            p = os.path.join("/kaggle/input", sub)
            try:
                inner = os.listdir(p)
            except OSError:
                inner = ["(无法读取)"]
            print(f"  /kaggle/input/{sub}/  ->  {inner[:8]}", flush=True)
        print("[诊断] 如果你挂的是 '作者数据包/别人的 kernel 输出', 里面没有 train.csv 和 train_series/,",
              "必须挂比赛数据本体 rsna-knee-abnormality-detection (Add Input -> Competitions 标签页)", flush=True)
    # 2) kagglehub 兜底:未挂载时自动下载比赛数据(Kaggle Notebook 内置凭据)
    try:
        import kagglehub
        d = kagglehub.competition_download("rsna-knee-abnormality-detection")
        if os.path.exists(os.path.join(d, "train.csv")):
            print(f"[路径] 未挂载,已用 kagglehub 获取数据: {d}", flush=True)
            return d, "/kaggle/working"
    except ImportError:
        pass  # 本地未装 kagglehub
    except Exception as e:
        print(f"[提示] kagglehub 下载数据失败: {e}", flush=True)
    # 3) 本地回退(脚本目录 / cwd / cwd 下的 rsna_knee 子目录都找)
    cands = []
    try:
        cands.append(os.path.dirname(os.path.abspath(__file__)))
    except NameError:
        pass
    cands.append(os.getcwd())
    for base in list(cands):
        cands.append(os.path.join(base, "rsna_knee"))
    seen = set()
    for base in cands:
        if base in seen:
            continue
        seen.add(base)
        if os.path.exists(os.path.join(base, "train.csv")):
            return base, base
    sys.exit("找不到数据:请先在比赛页加入比赛并同意数据规则,再 Add Input 挂载 "
             "rsna-knee-abnormality-detection;本地请在 rsna_knee/ 下运行。")


_PSEUDO_FILES = ("train_folds_with_pseudo.csv", "train_with_pseudo.csv",
                 "train_with_soft_labels.csv", "train_pseudo.csv")
_SKIP_DIRS = {"train_series", "test_series"}  # DICOM 大目录,绝不去遍历
_WEIGHT_EXT = (".pth", ".pt", ".ckpt", ".pth.tar")  # 离线预训练权重文件扩展名

# 12 标签多语言关键词词典(英/西/荷/德/法)——零挂载软标签兜底
# 命中 → 高置信,未命中 → 低置信(软标签,不给硬 0/1,避免错词误导)
_REPORT_KEYWORDS = {
    "ACL": ["acl", "anterior cruciate", "cruciado anterior", "voorste kruisband",
            "vorderen kreuzband", "lca", "ligament croisé antérieur"],
    "MCL": ["mcl", "medial collateral", "colateral medial", "mediale collaterale",
            "inneres seitenband", "ligament collatéral médial"],
    "Medial Meniscus": ["medial meniscus", "menisco interno", "meniscus medialis",
                        "meniskus medial", "menisque médial", "inner meniscus", "menisco medial"],
    "Lateral Meniscus": ["lateral meniscus", "menisco externo", "meniscus lateralis",
                         "meniskus lateral", "menisque latéral", "outer meniscus"],
    "Medial OA": ["medial osteoarthritis", "artrosis femorotibial medial",
                  "mediale gonartrose", "mediale arthrose", "osteoartritis medial",
                  "medial compartment narrowing", "medial joint space narrowing"],
    "Lateral OA": ["lateral osteoarthritis", "artrosis femorotibial lateral",
                   "laterale gonartrose", "laterale arthrose", "lateral joint space narrowing"],
    "PF OA": ["patellofemoral osteoarthritis", "artrosis patelofemoral",
              "patellofemorale artrose", "patellofemoral arthrose", "pf oa",
              "patellofemoral narrowing", "patellofemoral joint space"],
    "Effusion": ["effusion", "derrame", "vocht", "erguss", "épanchement", "joint effusion"],
    "Synovitis": ["synovitis", "sinovitis", "synoviale", "synovial thickening", "synovitis"],
    "Baker's": ["baker", "popliteal cyst", "quiste de baker", "baker cyst"],
    "Contusion": ["contusion", "bone bruise", "contusión", "kneuzing", "kontusion",
                  "marrow edema", "óseo", "bone bruising"],
    "Fracture": ["fracture", "fractura", "fractuur", "fraktur", "fracture line",
                 "fracture line", "subchondral fracture"],
}


def _pseudo_from_reports(train_csv, conf_hit=0.9, conf_miss=0.1):
    """从放射报告文本用多语言关键词生成 12 标签软标签(零挂载兜底)。

    返回 DataFrame(StudyInstanceUID + pseudo_* 列)。关键词命中→conf_hit,
    未命中→conf_miss(不给硬 0/1,降低错词误导)。官方已有标注的 study
    仍以官方为准(load_labels 的填充逻辑保证官方优先)。
    """
    if "Report" not in train_csv.columns:
        return None
    rep = train_csv["Report"].fillna("")
    rows = {}
    for lab, kws in _REPORT_KEYWORDS.items():
        low = [k.lower() for k in kws]
        rows[f"pseudo_{lab}"] = rep.apply(
            lambda t: conf_hit if any(k in str(t).lower() for k in low) else conf_miss)
    df = pd.DataFrame({"StudyInstanceUID": train_csv["StudyInstanceUID"], **rows})
    return df


def _print_mount_tree(base="/kaggle/input", tag="数据", max_files=6):
    """打印挂载目录树(最多两层,每目录前几个文件),帮用户确认挂载内容。"""
    if not os.path.isdir(base):
        print(f"[诊断-{tag}] 目录不存在: {base}", flush=True)
        return
    print(f"[诊断-{tag}] /kaggle/input 实际挂载内容:", flush=True)
    for sub in sorted(os.listdir(base)):
        p = os.path.join(base, sub)
        try:
            if os.path.isdir(p):
                inner = sorted(os.listdir(p))[:max_files]
                print(f"  {sub}/ -> {inner}", flush=True)
            else:
                print(f"  {sub} (文件)", flush=True)
        except OSError:
            print(f"  {sub} (无法读取)", flush=True)


def _print_dcm_tree(root, tag="DICOM", max_show=5):
    """打印 train_series 目录前几层真实结构 + 抽样 .dcm 计数,确认 DICOM 布局。

    RSNA 常见布局:train_series/<StudyInstanceUID>/<SeriesInstanceUID>/*.dcm(两层);
    也兼容一层(<SeriesInstanceUID>/*.dcm)或更深层,这里打印实际看到的。
    """
    dcm = os.path.join(root, "train_series")
    if not os.path.isdir(dcm):
        print(f"[诊断-{tag}] {dcm} 不存在!", flush=True)
        return
    try:
        subs_all = sorted(os.listdir(dcm))
    except OSError:
        subs_all = []
    subs = subs_all[:max_show]
    print(f"[诊断-{tag}] {dcm}", flush=True)
    print(f"[诊断-{tag}] 子目录/文件数: {len(subs_all)},样本:", flush=True)
    for s in subs:
        sp = os.path.join(dcm, s)
        if os.path.isdir(sp):
            try:
                inner = sorted(os.listdir(sp))[:max_show]
            except OSError:
                inner = []
            print(f"  {s}/ -> {inner}", flush=True)
            for it in inner[:2]:
                itp = os.path.join(sp, it)
                if os.path.isdir(itp):
                    try:
                        files = sorted(os.listdir(itp))[:3]
                    except OSError:
                        files = []
                    print(f"      {it}/ -> {files}", flush=True)
        else:
            print(f"  {s} (文件)", flush=True)
    # 抽样 .dcm 计数:前 3 study × 前 3 series
    n_dcm = 0
    try:
        for s in subs_all[:3]:
            sp = os.path.join(dcm, s)
            if not os.path.isdir(sp):
                continue
            for it in sorted(os.listdir(sp))[:3]:
                itp = os.path.join(sp, it)
                if os.path.isdir(itp):
                    n_dcm += sum(1 for f in os.listdir(itp) if f.lower().endswith(".dcm"))
    except OSError:
        pass
    print(f"[诊断-{tag}] 抽样 .dcm 文件数: {n_dcm}(前 3 study × 前 3 series)", flush=True)


def _scan_offline_weights(base="/kaggle/input", depth=0, max_depth=4):
    """递归扫描挂载目录下的预训练权重文件(.pth/.pt 等),跳过 DICOM 大目录。

    返回 [(绝对路径, 相对 /kaggle/input 的描述)];找不到返回空列表。
    社区打包的离线权重数据集(如 matteonaccarato/resnet34-imagenet-pth、
    marcshade/resnet-pretrained-weights-imagenet、pytorch/resnet34)挂载后即可被扫到,
    无需联网。
    """
    hits = []
    if depth > max_depth or not os.path.isdir(base):
        return hits
    try:
        entries = sorted(os.listdir(base))
    except OSError:
        return hits
    for fn in entries:
        p = os.path.join(base, fn)
        if os.path.isfile(p) and fn.lower().endswith(_WEIGHT_EXT):
            hits.append((p, os.path.relpath(p, "/kaggle/input")))
        elif os.path.isdir(p) and fn not in _SKIP_DIRS:
            hits.extend(_scan_offline_weights(p, depth + 1, max_depth))
    return hits


def _load_state_dict_from_file(path):
    """从权重文件读 state_dict(兼容:直接 state_dict / 包在 checkpoint 里 / 各种前缀)。

    读取失败或格式不对返回 None。
    """
    try:
        obj = torch.load(path, map_location="cpu", weights_only=True)
    except TypeError:  # 旧版 torch 无 weights_only 参数
        obj = torch.load(path, map_location="cpu")
    except Exception as e:
        print(f"[权重] {path} 读取失败: {e}", flush=True)
        return None
    if isinstance(obj, dict) and "state_dict" in obj:
        obj = obj["state_dict"]
    elif isinstance(obj, dict) and "model_state_dict" in obj:
        obj = obj["model_state_dict"]
    elif isinstance(obj, dict) and "model" in obj and isinstance(obj["model"], dict):
        obj = obj["model"]
    if not isinstance(obj, dict):
        return None
    # 剥常见前缀:module. / model. / backbone.(若整体带前缀,统一还原)
    out = {}
    for k, v in obj.items():
        for pre in ("module.", "model.", "backbone."):
            if k.startswith(pre):
                k = k[len(pre):]
                break
        out[k] = v
    return out


def _try_load_offline(net, paths):
    """按序尝试把候选离线权重加载进 net(state_dict 结构须与 ResNet34 匹配)。

    适配规则(面向社区 RSNA 权重,如 barun2104 的 best_resnet34_fold0.pth):
    - conv1.weight 通道数不同时:reshape+mean 适配到 net 的 conv1 通道数(如 24→3,
      barun2104 是 8 clip × 3 通道的 2.5D 模型);
    - fc.* / head.* / classifier.* 一律剥离(我们的模型会替换成 12 头);
    返回 (是否成功, 命中描述)。
    """
    for p, desc in paths:
        sd = _load_state_dict_from_file(p)
        if sd is None:
            continue
        # 1) 适配 conv1:通道数不同则 reshape+mean(如 24 通道 → 3 通道)
        if "conv1.weight" in sd:
            w = sd["conv1.weight"]
            target = net.conv1.weight.shape[1]
            if w.shape[1] != target and w.shape[1] % target == 0:
                B, C, H, W = w.shape
                w2 = w.reshape(B, target, C // target, H, W).mean(dim=2)
                sd["conv1.weight"] = w2
                print(f"[权重] {desc} conv1 通道 {C}→{target} 平均适配", flush=True)
            elif w.shape[1] != target:
                sd.pop("conv1.weight")  # 无法适配,丢弃(用随机初始化)
        # 2) 剥离 fc/head/classifier(模型会替换成 12 头)
        for k in list(sd.keys()):
            if k.startswith(("fc.", "head.", "classifier.")):
                sd.pop(k)
        try:
            missing, unexpected = net.load_state_dict(sd, strict=False)
        except Exception as e:
            print(f"[权重] {desc} 与 ResNet34 结构不匹配: {e}", flush=True)
            continue
        exempt = {k for k in missing if k.startswith(("conv1.", "fc."))}
        if not unexpected and len(missing) == len(exempt):
            print(f"[权重] 离线预训练加载成功: {desc} (覆盖 {len(sd)} 个参数张量)", flush=True)
            return True, desc
        print(f"[权重] {desc} 结构不匹配(missing {len(missing) - len(exempt)} 个非豁免 key, "
              f"unexpected {len(unexpected)}),尝试下一个", flush=True)
    return False, ""


def _scan_pseudo(base, depth=0, max_depth=3):
    """递归在挂载目录下找软标签 CSV(限制深度,跳过 DICOM 目录)。

    返回 (DataFrame 或 None, 来源描述)。识别规则:含 StudyInstanceUID 且至少有一个
    pseudo_ 前缀列(如 pseudo_ACL)。找不到返回 (None, "")。

    识别方式双通道:
    1. 文件名白名单(_PSEUDO_FILES)快速命中;
    2. **按内容识别**:任意 *.csv 只要表头含 StudyInstanceUID + pseudo_* 列即命中
       (不依赖文件名,社区数据集改名/换结构也能扫到)。
    """
    if depth > max_depth or not os.path.isdir(base):
        return None, ""
    try:
        entries = sorted(os.listdir(base))
    except OSError:
        return None, ""
    # 通道 1:文件名白名单(向后兼容,读全量)
    for fn in _PSEUDO_FILES:
        p = os.path.join(base, fn)
        if os.path.exists(p) and os.path.isfile(p):
            try:
                cand = pd.read_csv(p)
            except Exception:
                continue
            if "StudyInstanceUID" in cand.columns and any(
                    c.startswith("pseudo_") for c in cand.columns):
                return cand, os.path.relpath(p, "/kaggle/input")
    # 通道 2:按内容识别(只读表头 nrows=3 判断,命中再全读)
    for fn in entries:
        if not fn.lower().endswith(".csv"):
            continue
        p = os.path.join(base, fn)
        if not os.path.isfile(p):
            continue
        try:
            head = pd.read_csv(p, nrows=3)
        except Exception:
            continue
        if "StudyInstanceUID" in head.columns and any(
                c.startswith("pseudo_") for c in head.columns):
            try:
                cand = pd.read_csv(p)
                return cand, os.path.relpath(p, "/kaggle/input")
            except Exception:
                continue
    for sub in entries:
        if sub in _SKIP_DIRS:
            continue
        cand, src = _scan_pseudo(os.path.join(base, sub), depth + 1, max_depth)
        if cand is not None:
            return cand, src
    return None, ""


def find_pseudo_dataset():
    """在 /kaggle/input 下递归扫描社区软标签数据集(LLM 从报告提取的伪标签)。

    兼容单层(/kaggle/input/<slug>/)与多层(/kaggle/input/datasets/<slug>/)挂载。
    返回 (DataFrame 或 None, 来源描述);找不到返回 (None, "")。
    """
    if not os.path.isdir("/kaggle/input"):
        return None, ""
    return _scan_pseudo("/kaggle/input")


def load_labels(root, pseudo_conf=0.0, use_report_labels=True):
    """返回 train study 级标签 DataFrame(行=StudyInstanceUID, 列=LABELS, 分数/NaN)。

    标签来源优先级(2026-09-06 起;旧的"社区软标签数据集"方案已证伪弃用——
    barun2104 的 pseudo_* 98.7% 是字面 0.5 死值、零增量信息,是 loss 恒 0.693
    的真根因):
    1. 官方 train.csv 标注(0/1,仅 58/4407 例);
    2. 内置报告规则抽取器 rsna_report_labels(移植自 rsna-knee-baseline-v1,
       多语言/按句否定极性/严重度分级):对每份放射报告产出 12 病灶 soft 分数
       (阳性 0.72~0.95 / 阴性 0.04~0.20 / 无证据=NaN);
       官方缺失格用抽取分数填充,无证据格保持 NaN(不进损失,由 valid 掩码排除)。
    """
    train = pd.read_csv(os.path.join(root, "train.csv"))
    df = train[["StudyInstanceUID"] + LABELS].copy()
    official_cnt = {c: int(df[c].notna().sum()) for c in LABELS}

    if not use_report_labels:
        print("[标签] --no-report-labels:仅官方标注可用")
        return df
    if not HAS_RL:
        print("[标签] 未找到 rsna_report_labels.py(需与 rsna_v3.py 同目录),"
              "仅官方标注可用")
        return df
    if "Report" not in train.columns:
        print("[标签] train.csv 无 Report 列,仅官方标注可用")
        return df

    pseudo = RL.build_pseudo_table(train, verbose=True)
    pseudo = pseudo.set_index("StudyInstanceUID")
    print(f"[标签] 填充统计({len(df)} 个 study):")
    for c in LABELS:
        mask = df[c].isna().values
        if not mask.any():
            print(f"  {c:18s} 官方全量,无需填充")
            continue
        uids = df.loc[mask, "StudyInstanceUID"]
        vals = pseudo["pseudo_" + c].reindex(uids).values
        n_fill = int(pd.notna(vals).sum())
        df.loc[mask, c] = vals
        print(f"  {c:18s} 官方 {official_cnt[c]:4d} + 报告抽取填充 {n_fill:4d}"
              f" = 有效 {int(df[c].notna().sum()):5d}")
    return df


_DCM_MISS_PRINTED = [False]  # 只打印一次 DICOM 未命中诊断,避免 2 万 series 刷屏


def read_dicom_slices(dcm_dir, series_uid, study_uid=None):
    """读取一个 series 的所有切片,按物理位置排序,返回 [(path, z)]。

    路径兼容多种 Kaggle 布局(实测 RSNA 2026 为两层):
      1) <dcm_dir>/<series_uid>/                (旧假设:series 目录直接挂)
      2) <dcm_dir>/<study_uid>/<series_uid>/    (RSNA 标准:study 目录下再挂 series)
    找不到或读不到返回 []。
    """
    cands = [os.path.join(dcm_dir, series_uid)]
    if study_uid:
        cands.append(os.path.join(dcm_dir, study_uid, series_uid))
    sdir = next((c for c in cands if os.path.isdir(c)), None)
    if sdir is None:
        if not _DCM_MISS_PRINTED[0]:
            _DCM_MISS_PRINTED[0] = True
            print(f"[诊断-DICOM] 找不到 series 目录,尝试过: {cands}", flush=True)
            print(f"[诊断-DICOM] {dcm_dir} 是否存在: {os.path.isdir(dcm_dir)}", flush=True)
            try:
                inner = sorted(os.listdir(dcm_dir))[:8] if os.path.isdir(dcm_dir) else []
                print(f"[诊断-DICOM] {dcm_dir} 实际内容样本: {inner}", flush=True)
            except OSError:
                pass
        return []
    files = [os.path.join(sdir, f) for f in os.listdir(sdir) if f.lower().endswith(".dcm")]
    if not files:
        if not _DCM_MISS_PRINTED[0]:
            _DCM_MISS_PRINTED[0] = True
            print(f"[诊断-DICOM] 目录存在但无 .dcm 文件: {sdir}", flush=True)
            print(f"[诊断-DICOM] 目录内容样本: {sorted(os.listdir(sdir))[:8]}", flush=True)
        return []
    rows = []
    for f in files:
        try:
            d = pydicom.dcmread(f, stop_before_pixels=False)
            pos = d.get("ImagePositionPatient")
            z = float(pos[2]) if pos is not None and len(pos) >= 3 else None
            rows.append((f, z))
        except Exception:
            continue
    rows.sort(key=lambda r: (r[1] is None, r[1] if r[1] is not None else 0.0))
    return rows


# ---------------- DICOM -> 2.5D clip 预处理 ----------------

def window_and_resize(dcm, img_size=IMG_SIZE):
    """单张切片:Rescale 后百分位窗口化 -> [0,1] -> resize 224。"""
    arr = dcm.pixel_array.astype(np.float32)
    slope = float(dcm.get("RescaleSlope", 1))
    inter = float(dcm.get("RescaleIntercept", 0))
    arr = arr * slope + inter
    if dcm.get("PhotometricInterpretation") == "MONOCHROME1":
        arr = arr.max() - arr
    lo, hi = np.percentile(arr, [1, 99])
    arr = np.clip((arr - lo) / max(hi - lo, 1e-6), 0, 1)
    from PIL import Image
    img = Image.fromarray((arr * 255).astype(np.uint8)).resize((img_size, img_size), Image.BILINEAR)
    return np.asarray(img, dtype=np.float32) / 255.0


def make_clips(series_rows, n_clips=2, img_size=IMG_SIZE):
    """从排序好的切片列表生成若干 3 通道 clip(相邻三张)。"""
    clips = []
    paths = [r[0] for r in series_rows]
    if len(paths) < CLIP:
        return clips
    step = max(1, (len(paths) - 2) // n_clips)
    for c in range(1, len(paths) - 1, step):
        if len(clips) >= n_clips:
            break
        chan = []
        ok = True
        for k in (c - 1, c, c + 1):
            try:
                dcm = pydicom.dcmread(paths[k])
                chan.append(window_and_resize(dcm, img_size))
            except Exception:
                ok = False
                break
        if ok:
            clips.append(np.stack(chan, axis=0))  # (3, H, W)
    return clips


if HAS_TORCH:
    # ---------------- 数据集(v2:按平面过滤 series) ----------------

    class KneeDataset(Dataset):
        """study 级数据集,只取指定 Anatomical_Plane 的 series,拼成 (C*3, H, W)。"""

        def __init__(self, studies, labels_df, dcm_root, series_df, plane,
                     has_targets=True, n_clips=2):
            self.studies = studies
            self.labels_df = labels_df
            self.dcm_root = dcm_root
            self.series_df = series_df
            self.plane = plane
            self.has_targets = has_targets
            self.n_clips = n_clips
            self.cache = {}  # 每折独立缓存:fold 结束随 dataset 释放,避免 5 折累积 OOM
            # 诊断计数:读到 clip 的 study / 空 study / 累计 clip 数
            self.n_hit = 0
            self.n_empty = 0
            self.n_clips_total = 0

        def stats(self):
            """返回 (读到 clip 的 study 数, 空 study 数, 平均 clip 数),防止静默白训练。"""
            total = self.n_hit + self.n_empty
            avg = (self.n_clips_total / self.n_hit) if self.n_hit else 0.0
            return self.n_hit, self.n_empty, avg

        def _load_study(self, uid):
            key = (uid, self.plane)
            if key in self.cache:
                return self.cache[key]
            srows = self.series_df[self.series_df["StudyInstanceUID"] == uid]
            if "Anatomical_Plane" in srows.columns:
                srows = srows[srows["Anatomical_Plane"] == self.plane]
                srows = srows.sort_values("Fluid_Sensitive", kind="stable").drop_duplicates(
                    subset=["Fluid_Sensitive"]).head(MAX_SERIES)
            else:
                srows = srows.head(MAX_SERIES)
            clips = []
            for _, sr in srows.iterrows():
                sid = sr["SeriesInstanceUID"]
                rows = read_dicom_slices(self.dcm_root, sid, study_uid=uid)
                clips.extend(make_clips(rows, n_clips=self.n_clips))
            self.cache[uid] = clips
            # 仅首次加载计数(缓存命中不再累加,避免多 epoch 重复)
            if clips:
                self.n_hit += 1
                self.n_clips_total += len(clips)
            else:
                self.n_empty += 1
            return clips

        def __len__(self):
            return len(self.studies)

        def __getitem__(self, i):
            uid = self.studies[i]
            clips = self._load_study(uid)  # 命中/空计数在 _load_study 首次加载时完成
            in_ch = self.n_clips * CLIP  # 输入通道数:clip 数 × 每 clip 3 切片
            if not clips:
                x = np.zeros((in_ch, IMG_SIZE, IMG_SIZE), dtype=np.float32)
            else:
                x = np.concatenate(clips[: self.n_clips], axis=0)  # (k*3, H, W)
                pad = in_ch - x.shape[0]
                if pad > 0:
                    x = np.concatenate([x, np.zeros((pad, IMG_SIZE, IMG_SIZE), dtype=np.float32)])
                elif pad < 0:
                    x = x[: in_ch]
            x = torch.tensor(x, dtype=torch.float32)
            y = torch.zeros(len(LABELS), dtype=torch.float32)
            valid = torch.zeros(len(LABELS), dtype=torch.float32)
            if self.has_targets:
                row = self.labels_df[self.labels_df["StudyInstanceUID"] == uid]
                if len(row):
                    for j, c in enumerate(LABELS):
                        v = row.iloc[0][c]
                        if pd.notna(v):
                            y[j] = float(v)
                            valid[j] = 1.0
            return x, y, valid


    # ---------------- 模型 ----------------

    _PRETRAINED_TRIED = [False]  # 模块级标志:下载失败过一次就不再反复重试


    def _build_resnet34(use_pretrained=False, offline_paths=None):
        """构造 ResNet34 并加载 ImageNet 预训练权重。

        权重来源优先级:
        1. offline_paths:挂载的离线权重文件(扫描 /kaggle/input 得到,无需联网);
        2. use_pretrained=True:联网下载 torchvision 权重(带重试,失败回退随机);
        3. 否则随机初始化。
        成功加载后权重由 torch 缓存,后续 fold 秒加载。
        """
        net = tvm.resnet34(weights=None)
        if offline_paths:
            ok, desc = _try_load_offline(net, offline_paths)
            if ok:
                return net
            print(f"[权重] 离线候选均不匹配({desc}),回退到随机/联网路径", flush=True)
        if not use_pretrained:
            print("[权重] 未开启 --pretrained 且无离线权重,使用随机初始化"
                  "(不联网;如需预训练请加 --pretrained 并开启 Internet,"
                  "或挂载离线权重数据集)", flush=True)
            return net
        if _PRETRAINED_TRIED[0]:
            return net  # 之前已确认下载不了,直接随机
        for attempt in range(1, 4):
            try:
                net = tvm.resnet34(weights=tvm.ResNet34_Weights.IMAGENET1K_V1
                                   if hasattr(tvm, "ResNet34_Weights") else None)
                return net
            except Exception as e:
                print(f"[权重] ResNet34 预训练下载失败(第 {attempt}/3 次): {e}", flush=True)
                time.sleep(5)
        _PRETRAINED_TRIED[0] = True
        print("[权重] 3 次均失败,改用随机初始化(精度会明显下降;建议重试或挂载预训练权重数据集)", flush=True)
        return tvm.resnet34(weights=None)


    class KneeModel(nn.Module):
        """ResNet34 共享 backbone + 全局池化 + 12 sigmoid 头(每个平面一个实例)。"""

        def __init__(self, num_labels=len(LABELS), channels=CLIP, pretrained=False, offline_paths=None):
            super().__init__()
            if HAS_TV:
                self.backbone = _build_resnet34(use_pretrained=pretrained,
                                                offline_paths=offline_paths)
            else:
                raise RuntimeError("需要 torchvision(请在 Kaggle Notebook GPU 环境运行)")
            conv1_w = self.backbone.conv1.weight  # 保留预训练 conv1 权重
            self.backbone.conv1 = nn.Conv2d(channels, 64, kernel_size=7, stride=2, padding=3, bias=False)
            if conv1_w.shape == self.backbone.conv1.weight.shape:  # channels==3 时直接沿用
                self.backbone.conv1.weight.data.copy_(conv1_w.data)
            elif channels % 3 == 0 and conv1_w.shape[1] == 3:
                # 2.5D 通道扩展:把 3 通道预训练权重复制 n_clips 份(常见做法)
                rep = channels // 3
                self.backbone.conv1.weight.data.copy_(conv1_w.repeat(1, rep, 1, 1))
                print(f"[权重] conv1 预训练权重复制 {rep} 份扩展到 {channels} 通道", flush=True)
            self.backbone.fc = nn.Identity()
            self.head = nn.Linear(512, num_labels)

        def forward(self, x):
            feat = self.backbone(x)  # (B, 512)
            return self.head(feat)   # logits (B, 12)



# ---------------- 训练 / 验证 ----------------

def train_epoch(model, loader, opt, crit, device):
    model.train()
    tot, cnt = 0.0, 0
    for x, y, valid in loader:
        x, y, valid = x.to(device), y.to(device), valid.to(device)
        opt.zero_grad()
        out = model(x)
        if valid.sum() == 0:
            continue
        loss = (crit(out, y) * valid).sum() / valid.sum()
        loss.backward()
        opt.step()
        tot += loss.item() * len(x)
        cnt += len(x)
    return tot / max(cnt, 1)


def predict(model, loader, device):
    model.eval()
    rows = []
    with torch.no_grad():
        for x, _, _ in loader:
            x = x.to(device)
            out = torch.sigmoid(model(x))
            # .cpu().tolist() 而非 .cpu().numpy():torch 2.2.0+cu118 编于 numpy1.x,
            # 在 Kaggle numpy2.0.2 下 torch→numpy interop 崩;tolist 纯 C++ 路径安全。
            rows.extend(out.cpu().tolist())
    return np.asarray(rows, dtype=np.float32) if rows else np.zeros((0, len(LABELS)), dtype=np.float32)


def run_fold(model, train_ds, val_ds, device, args):
    train_loader = DataLoader(train_ds, batch_size=args.batch, shuffle=True,
                              num_workers=args.workers, drop_last=False)
    val_loader = DataLoader(val_ds, batch_size=args.batch, shuffle=False,
                            num_workers=args.workers, drop_last=False)
    opt = AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
    sched = CosineAnnealingLR(opt, T_max=args.epochs)
    crit = nn.BCEWithLogitsLoss(reduction="none")
    for ep in range(args.epochs):
        t0 = time.time()
        loss = train_epoch(model, train_loader, opt, crit, device)
        sched.step()
        if args.verbose:
            print(f"  epoch {ep + 1}/{args.epochs} loss {loss:.4f} ({time.time() - t0:.0f}s)", flush=True)
    val_pred = predict(model, val_loader, device)
    # DICOM 命中诊断:训练+验证已迭代完毕,此时计数才准确
    th, eh, at = train_ds.stats()
    vh, ev, av = val_ds.stats()
    print(f"[数据] train 命中 {th}/{len(train_ds)} study(空 {eh}, 平均 {at:.1f} clip) | "
          f"val 命中 {vh}/{len(val_ds)} study(空 {ev})", flush=True)
    if th == 0 or vh == 0:
        print("[警告] 有折 DICOM 全部没读到(命中 0)——输入将是全零,分数必然 ~0.5!", flush=True)
    val_uid = np.array(val_ds.studies)  # shuffle=False,顺序与数据集一致
    return val_pred, val_uid


# ---------------- 推理 / 融合 / 提交 ----------------

def predict_test(model, test_df, series_df, root, device, plane, n_clips=2):
    """对 test 每个 study 按指定平面收集 clips,预测 12 个概率。"""
    ds = KneeDataset(test_df["StudyInstanceUID"].tolist(), None, root, series_df,
                     plane, has_targets=False, n_clips=n_clips)
    loader = DataLoader(ds, batch_size=16, shuffle=False, num_workers=0)
    return predict(model, loader, device)


def plane_oof_auc(oof, labels_df, uid_list):
    """计算一个平面模型在指定 study 子集上的宏平均 OOF AUC(只算有标注的列)。

    labels_df 必须是【官方 gold 原始表】(0/1/NaN,如 train_csv 原列),不能传
    load_labels 填充后的 soft 表——soft 伪标签既非 ground truth,也会让
    roc_auc_score 崩(continuous)。58 例小样本下某列可能只有单一类别,跳过该列。
    """
    aucs = []
    for j, c in enumerate(LABELS):
        y_true = labels_df.set_index("StudyInstanceUID")[c].reindex(uid_list).values.astype(float)
        valid = ~np.isnan(y_true)
        if valid.sum() >= 20:
            yv = y_true[valid]
            if len(np.unique(yv)) < 2:
                continue
            aucs.append(roc_auc_score(yv, oof[valid, j]))
    return float(np.mean(aucs)) if aucs else 0.0


# ---------------- artifact / resume / ensemble helpers ----------------

def _artifact_root(args):
    base = Path(getattr(args, "artifact_dir", "") or "artifacts")
    exp = getattr(args, "experiment_id", "exp_001_5fold_sagittal")
    return base / exp


def _fold_meta_path(artifact_root, fold):
    return artifact_root / f"fold{fold}" / "meta.json"


def _is_fold_done(artifact_root, fold):
    p = _fold_meta_path(artifact_root, fold)
    if not p.exists():
        return False
    try:
        meta = json.loads(p.read_text(encoding="utf-8"))
        return meta.get("completion_status") == "done"
    except Exception:
        return False


def _save_fold_artifact(artifact_root, fold, test_pred, test_uids, meta):
    fold_dir = artifact_root / f"fold{fold}"
    fold_dir.mkdir(parents=True, exist_ok=True)
    np.save(str(fold_dir / "test_pred.npy"), test_pred.astype(np.float32))
    pd.DataFrame({"StudyInstanceUID": test_uids}).to_csv(
        fold_dir / "test_uid.csv", index=False
    )
    meta["completion_status"] = "done"
    meta["prediction_shape"] = list(test_pred.shape)
    (fold_dir / "meta.json").write_text(
        json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8"
    )


def _load_fold_predictions(artifact_root, fold, canonical_uids):
    fold_dir = artifact_root / f"fold{fold}"
    pred = np.load(fold_dir / "test_pred.npy")
    uids = pd.read_csv(fold_dir / "test_uid.csv")["StudyInstanceUID"].tolist()
    if pred.shape != (len(canonical_uids), len(LABELS)):
        raise ValueError(f"fold{fold} shape mismatch: {pred.shape} vs expected {(len(canonical_uids), len(LABELS))}")
    if uids != canonical_uids:
        raise ValueError(f"fold{fold} UID order mismatch")
    if not np.isfinite(pred).all():
        raise ValueError(f"fold{fold} contains NaN/Inf")
    if pred.min() < 0 or pred.max() > 1:
        raise ValueError(f"fold{fold} predictions out of [0,1]")
    return pred


def _save_experiment_meta(artifact_root, train_fold_uids, test_uids, args):
    meta = {
        "experiment_id": getattr(args, "experiment_id", "exp_001_5fold_sagittal"),
        "git_commit": __git_commit(),
        "args": vars(args),
        "labels": LABELS,
        "train_fold0_uids": train_fold_uids,
        "test_uids": test_uids,
    }
    (artifact_root / "config.json").write_text(
        json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8"
    )
    pd.DataFrame({"StudyInstanceUID": test_uids}).to_csv(
        artifact_root / "test_uid.csv", index=False
    )
    fold_rows = []
    for k in range(args.folds):
        fold_rows.append({"fold": k, "train_uids": train_fold_uids[k]})
    pd.DataFrame(fold_rows).to_csv(artifact_root / "fold_assignment.csv", index=False)


def _maybe_kaggle_dataset_version(artifact_root, message):
    if os.environ.get("KAGGLE_KERNEL_RUN_TYPE") != "Interactive":
        return
    slug = os.environ.get("KAGGLE_KERNEL_SLUG", "rsna-artifacts-tmp")
    owner = os.environ.get("KAGGLE_USERNAME", "ziyiming")
    dataset_id = f"{owner}/{slug}"
    try:
        subprocess.run(
            [
                "kaggle",
                "datasets",
                "version",
                "-p",
                str(artifact_root),
                "-m",
                message,
                "--dir-mode",
                "tar",
            ],
            check=True,
            capture_output=True,
        )
        print(f"[artifact] uploaded dataset version: {dataset_id}", flush=True)
    except Exception as e:
        print(f"[artifact] dataset upload skipped: {e}", flush=True)


def __git_commit():
    try:
        import subprocess
        return subprocess.check_output(
            ["git", "rev-parse", "HEAD"], text=True
        ).strip()
    except Exception:
        return "unknown"


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--epochs", type=int, default=2)
    ap.add_argument("--batch", type=int, default=8)
    ap.add_argument("--lr", type=float, default=3e-4)
    ap.add_argument("--workers", type=int, default=0)
    ap.add_argument("--n-clips", type=int, default=2)
    ap.add_argument("--seed", type=int, default=SEED)
    ap.add_argument("--folds", type=int, default=FOLDS)
    ap.add_argument("--only-fold", type=int, default=-1,
                    help="只跑指定折(其余跳过;默认 -1=全部)。探路用:--folds 5 --only-fold 0 训第 0 折"
                         "(train 4/5 与正式同分布),test 推理用该折模型出提交")
    ap.add_argument("--planes", type=str, default=",".join(PLANES),
                    help="逗号分隔的平面子集,如 axial,sagittal(小写,不区分大小写)")
    ap.add_argument("--fuse", type=str, default="weight",
                    choices=["weight", "mean"],
                    help="平面融合方式:weight=按 OOF AUC 加权;mean=简单平均")
    ap.add_argument("--pseudo-conf", type=float, default=0.0,
                    help="伪标签置信度过滤阈值(0=不过滤;0.5=丢弃置信度<0.5的伪标签)")
    ap.add_argument("--no-report-labels", action="store_true",
                    help="禁用内置报告关键词软标签兜底(默认开启:未挂社区数据集时"
                         "自动从 4407 份放射报告生成软标签,零挂载)")
    ap.add_argument("--verbose", action="store_true")
    ap.add_argument("--pretrained", action="store_true",
                    help="尝试下载 ImageNet 预训练权重(需开启 Internet);默认随机初始化不联网")
    ap.add_argument("--offline-weights", type=str, default="",
                    help="逗号分隔的离线权重 .pth 路径(优先级最高);留空则自动扫描挂载目录")
    ap.add_argument("--no-offline-scan", action="store_true",
                    help="禁用自动扫描 /kaggle/input 下的离线权重文件")
    ap.add_argument("--data", type=str, default="",
                    help="显式指定数据根目录(如 kagglehub.competition_download 返回的 path),"
                         "指定后跳过自动查找")
    ap.add_argument("--artifact-dir", type=str, default="artifacts",
                    help="artifact 根目录(默认 artifacts)")
    ap.add_argument("--experiment-id", type=str, default="exp_001_5fold_sagittal",
                    help="experiment ID(用于 artifact 子目录)")
    ap.add_argument("--resume-dir", type=str, default="",
                    help="已有 artifact 目录,启动时扫描 meta.json 跳过已完成 fold")
    args, _ = ap.parse_known_args()

    resume_root = Path(args.resume_dir) if args.resume_dir else None
    if resume_root and args.artifact_dir and not args.experiment_id:
        args.experiment_id = resume_root.name

    if not HAS_TORCH or not HAS_TV or not HAS_PYDICOM:
        sys.exit("依赖缺失:请在 Kaggle Notebook(GPU)环境运行(torch/torchvision/pydicom);本地仅可做数据层验证。")

    np.random.seed(args.seed)
    torch.manual_seed(args.seed)

    if args.data:
        if os.path.exists(os.path.join(args.data, "train.csv")):
            root, out = args.data, args.data
            print(f"[数据] 使用 --data 指定目录: {root}")
        else:
            sys.exit(f"--data 指定目录 {args.data} 下没有 train.csv,请检查路径")
    else:
        root, out = resolve_paths()
    print(f"[数据] root={root}  out={out}")

    train_csv = pd.read_csv(os.path.join(root, "train.csv"))
    labels_df = load_labels(root, pseudo_conf=args.pseudo_conf,
                            use_report_labels=not args.no_report_labels)
    series_df = pd.read_csv(os.path.join(root, "train_series.csv"))
    test_df = pd.read_csv(os.path.join(root, "test.csv"))
    test_series = pd.read_csv(os.path.join(root, "test_series.csv"))
    dcm_train = os.path.join(root, "train_series")
    dcm_test = os.path.join(root, "test_series")
    print(f"[数据] train {len(train_csv)} study / test {len(test_df)} study / series {len(series_df)}")
    _print_dcm_tree(root, "DICOM")  # 打印 train_series 真实目录结构,确认布局

    planes = [p.strip().title() for p in args.planes.split(",") if p.strip()]
    planes = [p for p in planes if p in PLANES]
    if not planes:
        sys.exit(f"--planes 无效,可选: {PLANES}")
    print(f"[平面] 使用 {planes}")

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"[设备] {device}")

    # 离线预训练权重:显式指定优先,否则自动扫描 /kaggle/input
    offline_paths = []
    if args.offline_weights.strip():
        for p in [x.strip() for x in args.offline_weights.split(",") if x.strip()]:
            if os.path.isfile(p):
                offline_paths.append((p, p))
            else:
                print(f"[权重] --offline-weights 指定的文件不存在,跳过: {p}", flush=True)
    elif not args.no_offline_scan:
        offline_paths = _scan_offline_weights()
        if offline_paths:
            print(f"[权重] 自动扫描到 {len(offline_paths)} 个离线权重候选:", flush=True)
            for p, desc in offline_paths[:6]:
                print(f"  {desc}", flush=True)
            if len(offline_paths) > 6:
                print(f"  ... 共 {len(offline_paths)} 个", flush=True)
        else:
            print("[权重] 未在挂载目录发现离线权重(可挂载社区打包的 resnet34 权重数据集)", flush=True)
            _print_mount_tree("/kaggle/input", "权重")

    gkf = GroupKFold(n_splits=args.folds)
    groups = train_csv["StudyInstanceUID"].values

    # 每个平面独立跑折,记录 OOF 与 test 预测
    plane_oof, plane_test, plane_auc, plane_uids = {}, {}, {}, {}
    for plane in planes:
        print(f"\n########## 平面: {plane} ##########")
        oof = np.zeros((len(train_csv), len(LABELS)))
        artifact_root = _artifact_root(args)
        canonical_test_uids = test_df["StudyInstanceUID"].tolist()
        train_fold_uids = []
        for k, (tr_idx, va_idx) in enumerate(gkf.split(train_csv, groups=groups)):
            tr_studies = train_csv.iloc[tr_idx]["StudyInstanceUID"].tolist()
            va_studies = train_csv.iloc[va_idx]["StudyInstanceUID"].tolist()
            train_fold_uids.append(tr_studies)
            if args.only_fold >= 0 and k != args.only_fold:
                continue
            if resume_root and _is_fold_done(artifact_root, k):
                print(f"[artifact] fold {k} done, skip", flush=True)
                continue
            tr_ds = KneeDataset(tr_studies, labels_df, dcm_train, series_df, plane,
                                n_clips=args.n_clips)
            va_ds = KneeDataset(va_studies, labels_df, dcm_train, series_df, plane,
                                n_clips=args.n_clips)
            model = KneeModel(pretrained=args.pretrained,
                              offline_paths=offline_paths,
                              channels=args.n_clips * CLIP).to(device)
            print(f"[折 {k + 1}/{args.folds}] {plane} train {len(tr_ds)} / val {len(va_ds)}", flush=True)
            t0 = time.time()
            val_pred, val_uid = run_fold(model, tr_ds, va_ds, device, args)
            fold_train_time = time.time() - t0
            for j, uid in enumerate(val_uid):
                row = np.where(train_csv["StudyInstanceUID"].values == uid)[0]
                if len(row):
                    oof[row[0]] = val_pred[j]
            t0 = time.time()
            test_pred = predict_test(model, test_df, test_series, dcm_test, device, plane, n_clips=args.n_clips)
            fold_inference_time = time.time() - t0
            meta = {
                "fold": k,
                "plane": plane,
                "n_clips": args.n_clips,
                "image_size": IMG_SIZE,
                "epochs": args.epochs,
                "batch_size": args.batch,
                "seed": args.seed,
                "git_commit": __git_commit(),
                "fold_train_time_sec": fold_train_time,
                "fold_inference_time_sec": fold_inference_time,
            }
            _save_fold_artifact(artifact_root, k, test_pred, canonical_test_uids, meta)
            print(f"[artifact] saved fold{k} -> {artifact_root / f'fold{k}'}", flush=True)
        # experiment-level meta once per plane
        _save_experiment_meta(artifact_root, train_fold_uids, canonical_test_uids, args)
        print(f"[artifact] saved experiment meta -> {artifact_root}", flush=True)
        # 该平面 OOF AUC(宏平均)
        uid_list = train_csv["StudyInstanceUID"].tolist()
        if args.only_fold >= 0:
            print(f"[{plane}] 探路模式(--only-fold {args.only_fold}):OOF 单折不完整,"
                  f"跳过 OOF AUC(权重记 0=均等);test 推理用该折模型")
            auc = 0.0
        else:
            auc = plane_oof_auc(oof, train_csv[["StudyInstanceUID"] + LABELS], uid_list)
            print(f"[{plane}] OOF 宏平均 AUC {auc:.4f}")
        plane_oof[plane], plane_auc[plane], plane_uids[plane] = oof, auc, uid_list
        # load saved fold predictions for this plane
        per_fold = []
        missing = []
        for k in range(args.folds):
            p = artifact_root / f"fold{k}" / "test_pred.npy"
            if not p.exists():
                missing.append(k)
                continue
            try:
                per_fold.append(_load_fold_predictions(artifact_root, k, canonical_test_uids))
            except Exception as e:
                missing.append(k)
                print(f"[ensemble] fold{k} invalid: {e}", flush=True)
        if len(missing) == args.folds:
            sys.exit(f"[ensemble] no valid fold predictions available under {artifact_root}")
        if missing:
            print(f"[ensemble] missing folds: {missing}; ensemble with available folds only", flush=True)
        plane_test[plane] = np.mean(per_fold, axis=0) if per_fold else None
        if plane_test[plane] is not None:
            print(f"[ensemble] {plane} ensembled from {len(per_fold)} folds, shape={plane_test[plane].shape}")

    # 融合
    if args.fuse == "weight":
        wsum = sum(max(a, 1e-6) for a in plane_auc.values())
        weights = {p: max(a, 1e-6) / wsum for p, a in plane_auc.items()}
        print(f"[融合] OOF AUC 加权: { {p: round(w, 4) for p, w in weights.items()} }")
    else:
        weights = {p: 1.0 / len(planes) for p in planes}
        print("[融合] 简单平均")
    fused = np.zeros_like(plane_test[planes[0]])
    for p, w in weights.items():
        fused += w * plane_test[p]
    sub = pd.DataFrame({"StudyInstanceUID": test_df["StudyInstanceUID"], **{
        LABELS[j]: fused[:, j] for j in range(len(LABELS))}})
    sub_path = os.path.join(out, "submission.csv")
    sub.to_csv(sub_path, index=False)
    print(f"\n提交文件已生成: {sub_path}  shape={sub.shape}")


if __name__ == "__main__":
    main()
\")\npath = \"/kaggle/working/rsna_v3.py\"\nwith open(path, \"w\", encoding=\"utf-8\") as f:\n    f.write(base64.b64decode(parts[0]).decode(\"utf-8\"))\nprint(f\"wrote rsna_v3.py ({os.path.getsize(path)} bytes)\")\n","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import base64, os\nparts = []\nparts.append('# -*- coding: utf-8 -*-
"""rsna_report_labels - 从放射报告文本抽取 12 病灶弱标签(多语言规则抽取器)

本文件由 top_kernels/rsna-knee-baseline-v1.ipynb 的抽取器(cells 6-11)原样移植,
负责把 4407 份多语言 MRI 放射报告转成 12 病灶的证据分数 + 置信度。

为什么存在:官方 gold 只有 58 study,社区"软标签"数据集 98.7% 是字面 0.5 死值
(零增量信息),导致 BCE 梯度约 0、loss 恒 0.693、模型学不动(2026-09-06 实证)。
报告文本里才有真正的信号——本抽取器即信号源。

用法(与 rsna_v3.load_labels 集成,零挂载,纯 CPU):
    import rsna_report_labels as R
    table = R.build_pseudo_table(train_df)   # StudyInstanceUID + pseudo_<12>(分数或 NaN)

输出语义(每个 (study, finding) 格):
    1) n_pos>0               -> soft 目标 = 证据分数(0.72~0.95,按严重度/重复分级)
    2) n_pos==0 and n_neg>0  -> soft 目标 = 证据分数(0.04~0.20,否定次数越多越低)
    3) 沉默 / 不确定         -> NaN(不进损失,由 KneeDataset valid 掩码排除)
    4) 官方 gold 由 load_labels 优先覆盖,本表只填空缺格。
"""
import pandas as pd

# --- 以下为社区抽取器原样移植(勿改词典) ---
# source: top_kernels/rsna-knee-baseline-v1.ipynb cells 6-11 (rule extractor section)
# normalise -> segment -> scope; nine languages pooled; stem+side proximity fallback;
# assertion/negation/hedge polarity per clause; graded severity scoring.


import re
import unicodedata

TARGETS = [
    "ACL", "MCL", "Medial Meniscus", "Lateral Meniscus",
    "Medial OA", "Lateral OA", "PF OA", "Effusion",
    "Synovitis", "Baker's", "Contusion", "Fracture",
]


# Turkish dotted/dotless i must be folded before casefolding, otherwise "İZLENMEZ"
# and "izlenmez" diverge. ß and the Croatian/Serbian d-with-stroke likewise.
_PRE = str.maketrans({
    "ı": "i", "İ": "i", "I": "i", "ß": "ss", "đ": "d", "Đ": "d",
    "ø": "o", "Ø": "o", "æ": "ae", "Æ": "ae",
})


def normalize(text: str) -> str:
    """Fold case, diacritics and separators; keep Greek and Cyrillic letters.

    NFKD decomposition strips Latin accents and Greek tonos alike (ά -> α), which is what
    we want: reports are inconsistent about accents. It also maps the MICRO SIGN U+00B5
    to a real mu, which matters because most Greek reports here use the wrong codepoint.
    """
    if not isinstance(text, str):
        return ""
    text = text.translate(_PRE).lower()
    text = unicodedata.normalize("NFKD", text)
    text = "".join(ch for ch in text if not unicodedata.combining(ch))
    text = text.replace("­", "")                    # soft hyphen
    text = re.sub(r"[_\-/\\]+", " ", text)
    text = re.sub(r"[ \t]+", " ", text)
    return text


_SENT_SPLIT = re.compile(r"(?<=[.;!?])\s+|\n+")


def clauses(text: str):
    """Split into clauses, then attach `header:` lines to the value that follows.

    A report line reading `Fractures :` followed by `Aucune.` is one statement. Splitting
    on punctuation alone separates the anatomy from its negation and flips the label.
    """
    norm = normalize(text)
    raw = [c.strip() for c in _SENT_SPLIT.split(norm) if c and c.strip()]

    merged = []
    for i, c in enumerate(raw):
        # A fragment ending in a colon is a heading for the next fragment. Structured
        # English reports write long ones - "lateral compartment (meniscus, collateral
        # ligament complex, cartilage):" is eight words - so the cap is generous.
        #
        # A merged heading must NOT also stand alone. On its own it carries the anatomy
        # word with no negation in scope, so `Fractures :` / `Aucune.` asserted a fracture
        # off the heading while the joined clause correctly read the denial. The joined
        # clause is a superset of the heading, so nothing is lost by dropping it; a
        # heading with no value beneath it is not merged and still stands.
        if c.endswith(":") and len(c.split()) <= 14 and i + 1 < len(raw):
            merged.append(c + " " + raw[i + 1])
        else:
            merged.append(c)
    # Comma-separated enumerations inside a long clause hide separate assertions.
    out = []
    for c in merged:
        out.append(c)
        if len(c.split()) > 25:
            out.extend(p.strip() for p in c.split(",") if len(p.split()) > 2)
    return out


def _rx(*alts: str) -> re.Pattern:
    return re.compile("|".join(alts))


NEGATION = _rx(
    # en
    r"\bno\b", r"\bnot\b", r"\bwithout\b", r"\bnegative for\b", r"\babsence\b",
    r"\bno evidence\b", r"\bunremarkable\b", r"\bfree of\b", r"\bnone\b", r"\bnil\b",
    # es
    r"\bsin\b", r"\bno hay\b", r"\bausencia\b", r"\bausentes?\b",
    # fr
    r"\bpas de\b", r"\bsans\b", r"\baucune?\b", r"\babsence\b",
    # nl
    r"\bgeen\b", r"\bzonder\b", r"\bniet\b",
    # de
    r"\bkeine?\b", r"\bohne\b", r"\bnicht\b",
    # tr
    r"\byok\b", r"\byoktur\b", r"izlenmemekte", r"saptanmadi", r"\bdegil\b",
    r"gozlenmemekte", r"mevcut degil", r"eslik etmiyor", r"\bizlenmedi\b",
    # hr / sr / bs
    r"\bnema\b", r"\bbez\b", r"\bnisu\b", r"\bnije\b",
    # el (accents already stripped)
    r"\bδεν\b", r"\bχωρις\b", r"ουδεν",
    # bg / ru
    r"\bбез\b", r"\bне\b", r"липсва", r"\bняма\b",
)

NORMALITY = _rx(
    r"\bnormal", r"\bintact\b", r"\bpreserved\b", r"\bwithin normal limits\b",
    r"limites normales", r"\bconservad", r"\bintegr", r"\bnormales\b",
    r"\bdoga(l|ll)\b", r"korunmus", r"\bnormaldir\b", r"olagan",
    r"\buredn", r"\bocuvan", r"\bodrzan", r"\bintakt",
    r"φυσιολογικ", r"ακεραι",
    r"unauffallig", r"regelrecht", r"\bintakt\b",
    r"нормал", r"запазен", r"съхранен", r"\bбез особености\b",
    r"\bgaaf\b", r"\bnormaal\b",
)

UNCERTAIN = _rx(
    r"\bpossible\b", r"\bprobable\b", r"\bsuspicious\b", r"\bsuspected\b",
    r"cannot (be )?exclude", r"\bmay\b", r"\bquestionable\b", r"\bequivocal\b",
    r"\bposible\b", r"sin criterios categoricos", r"\bdudos",
    r"\bmuhtemel\b", r"\bolasi\b", r"\bsupheli\b", r"\bizlenim",
    r"\bmoguce\b", r"\bvjerojatno\b", r"\bsumnja\b",
    r"πιθαν", r"υποπτ",
    r"\bmoglich", r"\bverdachtig", r"\bfraglich", r"\bV\.a\.\b",
    r"\bвъзможно\b", r"\bвероятно\b", r"суспект",
    r"\bmogelijk\b", r"\bverdacht\b",
)

# Pathology vocabulary shared by the paired rules.
TEAR = _rx(
    r"\btear", r"\btorn\b", r"\brupture", r"\bdisruption\b", r"discontinuit",
    r"\bavuls",
    r"\brotura\b", r"\broturas\b", r"\bruptura", r"\bdesgarro", r"\broto\b",
    r"\bdechirure", r"\bdechire",
    r"\bscheur", r"\bruptuur", r"gescheurd",
    r"riss(bildung|e|es)?\b", r"einriss", r"\bruptur", r"zerreiss", r"\blasion",
    r"\byirtik", r"\byirtig", r"\bkopma\b", r"butunluk kaybi", r"\brupturu\b",
    r"\bpuknuce", r"\bruptur", r"\bprekid\b", r"\bpukotin",
    r"ρηξη", r"ρηξις", r"ρηγμα",
    r"руптура", r"разкъсв", r"разрив", r"скъсв",
)

DEGEN = _rx(
    r"degenerat", r"\bmucoid\b", r"\bmyxoid\b", r"\bfray", r"\bfissur",
    r"dejeneratif", r"\bmukoid\b", r"degenerativn", r"εκφυλ", r"дегенерат",
    r"\bμυξοειδ", r"\bμυξωδ",
    r"\bmuco ?ide\b", r"aufgefasert",
)

INJURY = _rx(
    r"\binjur", r"\bsprain", r"\blesion", r"\blasion", r"\bedema\b", r"\boedema\b",
    r"\bodem\b", r"\bedem\b", r"\bοιδημα", r"\bодем", r"\bедем", r"\bstrain\b",
    r"\bhigh signal\b", r"\bsignal alteration\b", r"\bhiperintens", r"\bhyperintens",
    r"aumento de senal", r"alteracion de senal", r"cambio de senal",
    r"\bsignalanhebung", r"\bsignalalteration", r"verhoogd signaal", r"sinyal artis",
    r"αυξημενο σημα", r"повишен сигнал",
    r"\bthicken", r"\bzadebljanje\b", r"\bverdikking\b", r"\bdistenzij",
    r"\blaksite\b", r"\blaxity\b", r"\bpartial\b", r"\bparcijaln", r"\bparcial",
    r"\bpartiel", r"\bpartiell",
)


ANAT = {
    "ACL": _rx(
        r"anterior cruciate", r"\bacl\b",
        r"cruzado anterior", r"\blca\b",
        r"croise anterieur",
        r"voorste kruisband", r"\bvkb\b",
        r"vorderes kreuzband", r"vorderen kreuzband", r"vordere kreuzband",
        r"on capraz", r"\bocb\b",
        r"prednji krizni", r"prednjeg krizn",
        r"προσθι[οα][^ ]* χιαστ", r"προσθιου χιαστου", r"χιαστο[^ ]* συνδεσμ",
        # "χιαστοι και πλαγιοι συνδεσμοι" separates the adjective from its noun, so the
        # adjective stem has to stand alone. Greek marks cruciate with it unambiguously.
        r"\bχιαστ\w*",
        r"предна кръстна", r"предната кръстна",
        # Plural, unqualified: reports routinely clear both cruciates in one clause
        # ("Ligamentos cruzados y colaterales dentro de limites normales"), so the
        # plural form has to match without a side qualifier or the whole clause is lost.
        r"cruciate ligaments", r"ligamentos cruzados", r"ligaments croises",
        r"kruisbanden", r"kreuzbander", r"capraz baglar", r"krizn[a-z]* ligament[a-z]*",
        r"χιαστοι συνδεσμ", r"χιαστων συνδεσμ", r"кръстните връзки", r"кръстни връзки",
    ),
    "MCL": _rx(
        r"medial collateral", r"\bmcl\b", r"tibial collateral",
        r"colateral medial", r"colateral interno", r"\blcm\b",
        r"collateral medial", r"collateral interne",
        r"mediale collaterale", r"binnenband", r"\b(mediale|laterale) banden\b",
        r"\bcollaterale banden\b",
        r"innenband", r"mediales? kollateral",
        r"\bic yan bag", r"medial kollateral", r"\biyb\b",
        r"medijalni kolateraln", r"medijalnog kolateraln",
        r"εσω πλαγι", r"εσωτερικο πλαγι", r"\bπλαγι\w* συνδεσμ", r"\bπλαγιοι\b",
        r"медиален колатерал", r"вътрешна странична", r"\bколатерал\w*",
        # Same plural pattern as the cruciates.
        # "Ligamentos cruzados y colaterales" separates the noun from its adjective, so
        # the adjective has to stand alone as a cue.
        r"\bcolaterales\b", r"\bcollateraux\b", r"\bcollateralen\b", r"\bkolateralni\b",
        r"collateral ligaments", r"ligamentos colaterales", r"ligaments collateraux",
        r"collaterale banden", r"kollateralbander", r"seitenbander", r"yan baglar",
        r"kolateraln[a-z]* ligament[a-z]*", r"πλαγιοι συνδεσμ", r"πλαγιων συνδεσμ",
        r"колатерални връзки", r"страничните връзки",
    ),
    "Medial Meniscus": _rx(
        r"medial meniscus", r"\bmm\b(?= tear)", r"medial menisc",
        r"menisco medial", r"menisco interno",
        r"menisque medial", r"menisque interne",
        r"mediale meniscus", r"binnenmeniscus",
        r"innenmeniskus", r"medialen? meniskus", r"innenmeniskushinterhorn",
        r"medyal menisk", r"\bic menisk",
        r"medijalni meniskus", r"medijalnog meniskusa", r"medijalnom meniskusu",
        r"εσω μηνισκ", r"μηνισκ[^ ]* του εσω", r"εσω διαμερισμα[^.]{0,40}μηνισκ",
        r"медиалния менискус", r"медиален менискус", r"вътрешния менискус",
    ),
    "Lateral Meniscus": _rx(
        r"lateral meniscus", r"lateral menisc",
        r"menisco lateral", r"menisco externo",
        r"menisque lateral", r"menisque externe",
        r"laterale meniscus", r"buitenmeniscus",
        r"aussenmeniskus", r"lateralen? meniskus",
        r"lateral menisk", r"\bdis menisk",
        r"lateralni meniskus", r"lateralnog meniskusa", r"lateralnom meniskusu",
        r"εξω μηνισκ", r"μηνισκ[^ ]* του εξω", r"εξω διαμερισμα[^.]{0,40}μηνισκ",
        r"латералния менискус", r"латерален менискус", r"външния менискус",
    ),
}

# Osteoarthritis is rarely written as "osteoarthritis". It is written as cartilage loss,
# chondropathy grade, joint space narrowing, or osteophytes - scoped to a compartment.
OA_EVIDENCE = _rx(
    r"osteoarthrit", r"\barthros", r"\bgonarthros", r"\bosteoarthros",
    r"chondropath", r"chondromalac", r"condropat", r"condromalac",
    r"cartilage loss", r"cartilage thinning", r"chondral (loss|defect|ulcer|thinning)",
    r"osteophyt", r"osteofit", r"osteofyt", r"osteofito", r"osteophyten",
    r"joint space narrowing", r"pinzamiento articular",
    r"kikirdak kayb", r"kikirdak incelme", r"kondropati", r"kondral",
    r"kraakbeen(lijden|verlies)", r"gonartrose", r"artrose",
    r"knorpel(verlust|schaden|defekt)", r"arthrose", r"gonarthrose",
    r"hrskavic", r"hondromalac", r"artroz", r"osteoartrit",
    r"χονδρ[^ ]*παθ", r"αρθριτ", r"αρθρωσ", r"οστεοφυτ",
    r"αρθρικου χονδρου", r"εξαλειψη του αρθρικου χονδρου",
    r"артроз", r"хондропат", r"остеофит", r"хрущял[^.]{0,30}(изтън|увред|дефект)",
    r"ulcera[s]? condral", r"cartilago[^.]{0,25}(perdida|adelgaz)",
    r"icrs grade", r"outerbridge",
)

COMPARTMENT = {
    "Medial OA": _rx(
        r"medial (femorotibial|tibiofemoral|compartment)",
        r"compartimento femorotibial medial", r"femorotibial interno",
        r"mediaal femorotibiaal", r"mediale femorotibial",
        r"medial femorotibial", r"medialen kompartiment", r"innere[sn]? kompartiment",
        r"medyal femorotibial", r"ic kompartman", r"medyal kompartman",
        r"medijaln[^ ]* (femorotibi|odjelj|kompartm)",
        r"εσω διαμερισμα", r"εσω κνημιαι", r"εσω μηριαι",
        r"медиалн[^ ]* (компартм|отдел|тибиал|феморотиб)",
        r"medial (femoral|tibial) (condyle|plateau)", r"condilo femoral medial",
        r"medialen? (femurkondyl|tibiaplateau)", r"mediale femorale condyl",
    ),
    "Lateral OA": _rx(
        r"lateral (femorotibial|tibiofemoral|compartment)",
        r"compartimento femorotibial lateral", r"femorotibial externo",
        r"lateraal femorotibiaal", r"laterale femorotibial",
        r"lateral femorotibial", r"lateralen kompartiment", r"aussere[sn]? kompartiment",
        r"lateral femorotibial", r"dis kompartman", r"lateral kompartman",
        r"lateraln[^ ]* (femorotibi|odjelj|kompartm)",
        r"εξω διαμερισμα", r"εξω κνημιαι", r"εξω μηριαι",
        r"латералн[^ ]* (компартм|отдел|тибиал|феморотиб)",
        r"lateral (femoral|tibial) (condyle|plateau)", r"condilo femoral lateral",
        r"lateralen? (femurkondyl|tibiaplateau)", r"laterale femorale condyl",
    ),
    "PF OA": _rx(
        r"patellofemoral", r"femoropatellar", r"femoropatelar", r"patelofemoral",
        r"retropatellar", r"retrorotulian", r"\btrochlea", r"\btroclea", r"\btroklea",
        r"\bpatella\b", r"\bpatellar\b", r"\brotulian", r"\brotula\b", r"\bpatele\b",
        r"\bpatellae?\b", r"patellofemoraal", r"femoropatellair",
        r"επιγονατιδ", r"μηροεπιγονατιδ", r"τροχιλ",
        r"пател", r"феморопател", r"тролх",
        r"anterior compartment", r"compartimento anterior", r"prednj[^ ]* odjeljk",
    ),
}

# Self-declaring findings: the term itself is the finding.
DIRECT = {
    "Effusion": _rx(
        r"\beffusion", r"joint fluid", r"intra ?articular fluid", r"\bhydrops\b",
        r"derrame articular", r"\bderrame\b", r"liquido articular",
        r"epanchement",
        r"gewrichtsvocht", r"\bvocht\b", r"\bhydrops\b", r"gewrichtseffusie",
        r"gelenkerguss", r"\berguss\b", r"gelenksergu",
        # "diz eklemi ici sivi miktari ... artmis" and "eklem icerisinde yaygin sivi
        # artisi" both occur; the noun takes a possessive suffix, so `eklem ` alone
        # misses. Match the stem plus any suffix.
        r"eklem\w* ic\w* sivi", r"efuzyon", r"eklem sivisi",
        r"sivi (miktari|artisi|birikimi)", r"sivi artis", r"\bsivi\b[^.]{0,25}artmis",
        r"\bizljev", r"\bizliv", r"zglobn[^ ]* tekucin", r"\bhidrops\b",
        r"αρθρικ[^ ]* υγρ", r"υγρου ενδαρθρικα", r"ενδαρθρικ[^ ]* υγρ", r"ποσοτητα υγρου",
        r"ενδαρθρικ", r"αρθρικη συλλογη", r"υγρο στην αρθρωση", r"υγρου στην αρθρωση",
        r"ставен излив", r"излив", r"ставна течност", r"синовиална течност",
    ),
    "Synovitis": _rx(
        r"synovit", r"sinovit", r"synovial (thickening|proliferation|hypertroph)",
        r"synovitis", r"synoviale? (verdikking|proliferatie)",
        r"synovialitis", r"synovialis(verdickung|proliferation)",
        r"sinovijalitis", r"sinovitis", r"zadebljanje sinovij",
        r"υμενιτιδα", r"συνοβιτιδα", r"υμενικ[^ ]* υπερτροφ", r"αρθρικου υμεν",
        r"синовит", r"синовиал[^ ]* (задебел|пролифер)",
        r"verdikkingen van (het )?synovium", r"pannus",
    ),
    "Baker's": _rx(
        r"baker", r"popliteal cyst", r"quiste popliteo", r"quistes popliteos",
        r"kyste poplite", r"popliteale? cyst", r"poplitealzyste", r"bakerzyste",
        r"popliteal kist", r"\bbakerova\b", r"poplitealn[^ ]* cist",
        r"κυστη baker", r"πολυχωρη συνοβιακη κυστη", r"κυστη του baker",
        r"киста на бейкър", r"бейкърова киста", r"поплитеална киста",
        r"gastrocnemio ?semimembranos", r"gastrocnemius semimembranosus burs",
    ),
    "Contusion": _rx(
        r"\bcontusion", r"bone bruise", r"bone marrow (o?edema|contusion)",
        r"\bkontuz", r"medular bone o?edema", r"marrow o?edema",
        r"contusion osea", r"edema oseo", r"edema de medula osea",
        r"oedeme osseux", r"contusion osseuse",
        r"botcontusie", r"botoedeem", r"beenmergoedeem", r"botmergoedeem",
        r"knochenmarkodem", r"knochenodem", r"kontusion", r"bone bruise",
        r"kemik kontuzyonu", r"kemik iligi odemi", r"kemik odemi",
        r"kostani edem", r"edem kosti", r"kontuzij",
        r"οστεομυελικ[^ ]* οιδημα", r"οστικο οιδημα", r"μυελικο οιδημα",
        r"костномозъчен едем", r"костен едем", r"контузионен",
    ),
    "Fracture": _rx(
        r"\bfractur", r"\bfract\b",
        r"\bfractura", r"\bfracturas\b",
        r"\bfractuur", r"\bbreuk\b",
        r"\bfraktur", r"\bbruch\b",
        r"\bkirik\b", r"\bkirigi\b", r"\bkirik\b",
        r"\bfraktur", r"\bprijelom", r"impresijsk[^ ]* fraktur",
        r"καταγμα", r"καταγματ",
        r"фрактур", r"счупван", r"фисур",
        r"insufficiency fracture", r"stress fracture", r"avulsion fracture",
        r"subchondral fracture", r"subkondral kiri",
    ),
}

# Terms that look like a finding but are not the finding being scored.
DECOY = {
    # `no fracture` is deliberately absent: a decoy skips the clause, so listing it here
    # turned the commonest English denial into silence, and the study then pulled on the
    # fracture head with the weight of a report that never mentioned fractures at all.
    # `microfractur` is a surgical procedure and `fracture risk` a prediction; both stay.
    "Fracture": _rx(r"microfractur", r"\bfracture (risk|prophyla)"),
    "Baker's": _rx(r"meniscal cyst", r"quiste meniscal", r"ganglion"),
}

PAIRED = {"ACL", "MCL", "Medial Meniscus", "Lateral Meniscus"}
OA_TARGETS = {"Medial OA", "Lateral OA", "PF OA"}


STEM_MENISCUS = _rx(r"menisc\w*", r"menisk\w*", r"μηνισκ\w*", r"мениск\w*")
STEM_CRUCIATE = _rx(r"cruciate", r"cruzado", r"croise", r"kruisband", r"kreuzband",
                    r"capraz bag\w*", r"krizn\w*", r"χιαστ\w*", r"кръстн\w*",
                    r"\bacl\b", r"\bpcl\b", r"\blca\b", r"\blcp\b", r"\bvkb\b",
                    r"\bhkb\b", r"\bocb\b", r"\bacb\b")
STEM_COLLATERAL = _rx(r"collateral\w*", r"colateral\w*", r"kollateral\w*",
                      r"collaterale\w*", r"kolateraln\w*", r"yan bag\w*",
                      r"πλαγι\w*", r"колатерал\w*", r"странич\w*",
                      r"innenband\w*", r"aussenband\w*", r"binnenband\w*",
                      r"\bmcl\b", r"\blcl\b", r"\blcm\b", r"\biyb\b")

SIDE_MEDIAL = _rx(r"\bmedial\w*", r"\bmedyal\w*", r"\bmedijaln\w*", r"\bmediaal\w*",
                  r"\bmediale\w*", r"\bintern[oa]\w*", r"\binterne\w*", r"\binnen\w*",
                  r"\bic\b", r"\bunutarnj\w*", r"\bεσω\w*", r"\bεσωτερικ\w*",
                  r"\bмедиал\w*", r"\bвътреш\w*", r"\btibial collateral\b",
                  r"\bbinnen\w*", r"\bmediaal\b")
SIDE_LATERAL = _rx(r"\blateral\w*", r"\bextern[oa]\w*", r"\bexterne\w*", r"\bdis\b",
                   r"\blateraln\w*", r"\baussen\w*", r"\bbuiten\w*", r"\bεξω\w*",
                   r"\bεξωτερικ\w*", r"\bлатерал\w*", r"\bвъншн\w*",
                   r"\bfibular collateral\b", r"\bvanjsk\w*")
SIDE_ANTERIOR = _rx(r"\banterior\w*", r"\bant\b", r"\bon\b", r"\bprednj\w*",
                    r"\bvorder\w*", r"\bvoorste\b", r"\bπροσθι\w*", r"\bпредн\w*",
                    r"\banteriyor\w*", r"\bavant\b", r"\bant[eé]rieur\w*")

# The contrary of SIDE_ANTERIOR, needed only to stop a side-blind cruciate cue firing on
# the posterior ligament. It is never used to assert a target - there is no PCL target -
# so it is deliberately narrow: `posterior horn` is one of the commonest phrases in a
# knee report and must not be read as a cruciate qualifier, which is why the guard below
# tests proximity to the cruciate stem rather than presence in the clause.
SIDE_POSTERIOR = _rx(r"\bposterior\w*", r"\bpost[eé]rieur\w*", r"\bposteriore\w*",
                     r"\bhinter\w*", r"\bachterste\b", r"\barka\b", r"\bstraznj\w*",
                     r"\bzadnj\w*", r"\bοπισθι\w*", r"\bзадн\w*", r"\bpostero\w*")

# Fracture is the target whose stem varies most across the corpus.
STEM_FRACTURE = _rx(r"fractur\w*", r"fraktur\w*", r"fractuur\w*", r"\bfract\b",
                    r"kiri[kgğ]\w*", r"prijelom\w*", r"lom kosti", r"\bbreuk\w*",
                    r"\bbruch\w*", r"καταγμα\w*", r"καταγματ\w*", r"фрактур\w*",
                    # NOT a bare `fissur\w*`: "fisuras condrales" and "full thickness
                    # fissures in the articular cartilage" describe cartilage, not bone.
                    # The stem has to be anchored to a bone word to mean a fracture.
                    r"счупван\w*", r"fisur\w* (osea|oseas|kost)", r"fissur\w* kost")

STEM_OA_COMPARTMENT = _rx(r"compartment\w*", r"compartimento\w*", r"compartiment\w*",
                          r"kompartman\w*", r"kompartiment\w*", r"odjelj\w*",
                          r"διαμερισμα\w*", r"компартм\w*", r"\bотдел\w*",
                          r"femorotibial\w*", r"femorotibiaal\w*", r"tibiofemoral\w*",
                          r"femoro tibial\w*", r"κνημιαι\w*", r"μηριαι\w*",
                          r"femoral condyl\w*", r"tibial plateau\w*",
                          r"condilo femoral", r"platillo tibial", r"tibiaplateau\w*",
                          r"femurkondyl\w*", r"femoralne? kondil\w*",
                          r"tibijaln\w* plato", r"femoral kondil\w*",
                          r"tibia plato", r"tibyal plato")


def _distance(clause: str, stem_rx: re.Pattern, qual_rx: re.Pattern, window: int = 55):
    """Characters from the nearest stem to the nearest qualifier, or None if none is near.

    Character windows rather than token windows, because word order differs: English
    puts the side before the noun, Greek and Bulgarian often after, and Turkish
    attaches it as a separate preceding adjective.

    A distance rather than a yes. Presence is enough to decide that a qualifier applies
    to a structure, but not enough to decide which of two qualifiers applies: a knee
    report says "anterior horn" and "posterior horn" constantly, so any window wide
    enough to catch a real side word also catches an unrelated one, and two rules that
    both answer "yes" cannot be told apart. Comparing how far away they are can.
    """
    best = None
    for m in stem_rx.finditer(clause):
        lo = max(0, m.start() - window)
        hi = min(len(clause), m.end() + window)
        for q in qual_rx.finditer(clause[lo:hi]):
            qs, qe = lo + q.start(), lo + q.end()
            d = 0 if qs < m.end() and qe > m.start() else \
                min(abs(m.start() - qe), abs(qs - m.end()))
            best = d if best is None else min(best, d)
    return best


def _near(clause: str, stem_rx: re.Pattern, qual_rx: re.Pattern, window: int = 55):
    """True if a stem match has a qualifier within `window` characters either side."""
    return _distance(clause, stem_rx, qual_rx, window) is not None
    return False


# concept -> (stem, side) pairs used in addition to the phrase lexicons above
STEM_RULES = {
    "ACL": (STEM_CRUCIATE, SIDE_ANTERIOR),
    "MCL": (STEM_COLLATERAL, SIDE_MEDIAL),
    "Medial Meniscus": (STEM_MENISCUS, SIDE_MEDIAL),
    "Lateral Meniscus": (STEM_MENISCUS, SIDE_LATERAL),
    "Medial OA": (STEM_OA_COMPARTMENT, SIDE_MEDIAL),
    "Lateral OA": (STEM_OA_COMPARTMENT, SIDE_LATERAL),
}


SEV_LOW = _rx(
    r"\bsmall\b", r"\bminimal\b", r"\btrace\b", r"\bmild\b", r"\bslight\b",
    r"\btiny\b", r"\bscant\b", r"\bmimimal\b", r"\bdiscrete\b", r"\bfocal\b",
    r"\bleve\b", r"\bminim", r"\bpeque", r"\bligero\b", r"\bescaso\b", r"\bdiscreto\b",
    r"\bhafif\b", r"\bminimal\b", r"\baz miktarda\b", r"\bsilik\b",
    r"\bmanja\b", r"\bmanji\b", r"\bblago\b", r"\bdiskretn", r"\bmalo\b",
    r"\bgering", r"\bdiskret", r"\bkleine?r?\b", r"\bwenig\b", r"\bzarte?\b",
    r"\bbeperkte?\b", r"\bgeringe\b", r"\bweinig\b", r"\blichte?\b",
    r"\bηπι", r"\bμικρ", r"\bελαχιστ",
    r"\bминимал", r"\bлек", r"\bмалк", r"\bнеголям",
)

SEV_HIGH = _rx(
    r"\blarge\b", r"\bmarked\b", r"\bmassive\b", r"\bsevere\b", r"\bextensive\b",
    r"\bmoderate\b", r"\bgross\b", r"\bsignificant\b", r"\babundant\b", r"\btense\b",
    r"\bmoderad", r"\bimportante\b", r"\bsevera?\b", r"\bmarcad", r"\bcuantios",
    r"\bbelirgin\b", r"\byaygin\b", r"\bileri\b", r"\bciddi\b", r"\bbol\b",
    r"\bopsezan\b", r"\bveliki\b", r"\bizrazit", r"\bznacajn", r"\bumjeren",
    r"\bausgepragt", r"\bdeutlich", r"\bmassiv", r"\bmassig", r"\bgross",
    r"\buitgebreid", r"\bgevorderd", r"\bveel\b", r"\bmatige?\b",
    r"\bμετρι", r"\bμεγαλ", r"\bεκτεταμεν", r"\bευμεγεθ", r"\bσοβαρ",
    r"\bголям", r"\bизразен", r"\bзначим", r"\bумерен", r"\bобилен",
)

# OA is often asserted for the whole joint rather than per compartment
# ("tricompartmental osteoarthritis", "gonarthrose", "incipient OA of all three
# compartments"). Those statements are evidence for all three OA targets.
GLOBAL_OA = _rx(
    r"tri ?compartment", r"all three compartment", r"global(ised)? (oa|osteoarthrit)",
    r"\bgonarthros", r"\bgonartros", r"\bgonarthrose", r"\bgonartrose",
    r"osteoarthritis of the knee", r"artrosis (de |)(la )?rodilla", r"knee osteoarthrit",
    r"\bdiz osteoartrit", r"\bgonartroz", r"artroza koljena",
    r"οστεοαρθριτιδα", r"αρθριτιδα του γονατος",
    r"артроза на колянната", r"гонартроз",
    r"degenerative joint disease", r"\bdjd\b",
)

# A bare "bone marrow oedema" is not a contusion when it sits under a cartilage
# defect: subchondral oedema beneath a worn compartment is reactive degenerative signal,
# and reading it as a bruise turns every osteoarthritic knee into a trauma case.
DEGENERATIVE_MARROW = _rx(
    r"subchondral", r"subcondral", r"subkondral", r"supkondraln", r"subchondraln",
    r"υποχονδρι", r"субхондрал", r"subchondrale?",
    r"\bcyst", r"\bquist", r"\bzyste\b", r"\bcistic", r"reactive", r"reactivo",
)

TRAUMA = _rx(
    r"\bbruise\b", r"\bcontusion", r"\bkontuz", r"\bcontusion osea\b",
    r"\btrauma", r"\bimpaction\b", r"\bpivot shift\b", r"\bkissing\b",
    r"\bacute\b", r"\bagudo\b", r"\bakut", r"\bpivot kaymasi\b",
    r"\bcontusion osseuse\b", r"\bbone bruise\b", r"\bbotcontusie\b",
    r"\bконтузион", r"\bμωλωπ", r"\bkontuzij",
)


def _polarity(clause: str, anchor_end: int) -> str:
    """Classify one clause as positive, negative or uncertain for a matched term.

    Scope is the whole clause. Clause segmentation already keeps statements short, and
    a window in characters mis-scopes badly across languages with different word orders -
    Turkish puts its negator at the end of the sentence, English at the front.
    """
    if UNCERTAIN.search(clause):
        return "uncertain"
    if NEGATION.search(clause):
        return "negative"
    if NORMALITY.search(clause):
        # "meniscus normal" negates; "normal ... but tear" does not.
        if TEAR.search(clause) or re.search(r"\bgrade [34]\b", clause):
            return "positive"
        return "negative"
    return "positive"


class _Matcher:
    """Phrase lexicon first, stem+side proximity as the fallback.

    Exposes `.search` so it drops into the same slot as a compiled pattern.
    """

    def __init__(self, phrase_rx, stem=None, side=None, window=55, contrary=None):
        self.phrase_rx = phrase_rx
        self.stem = stem
        self.side = side
        self.window = window
        self.contrary = contrary

    def search(self, clause):
        m = self.phrase_rx.search(clause)
        if m is not None and not self._wrong_side(clause):
            return m
        if self.stem is not None and _near(clause, self.stem, self.side, self.window):
            return self.stem.search(clause)
        return None

    def _wrong_side(self, clause):
        """True when the clause names the other member of this structure's pair.

        Some cues in the lexicon are side-blind by design: Greek separates the adjective
        from its noun ("cruciate and collateral ligaments"), so the bare adjective stem
        has to stand alone or the clause is lost. That stem then also matches the
        posterior cruciate and the lateral collateral, neither of which is a target here,
        and a positive outranks every negative in the scorer - so one PCL clause was
        enough to override an explicit "the ACL is normal".

        The test is proximity to the structure's own stem, not presence in the clause.
        "Posterior horn of the medial meniscus" appears in a large share of knee reports
        and says nothing about a cruciate; only a qualifier sitting beside the ligament
        word is one. A clause naming both sides keeps the match, because it does mention
        this target.
        """
        if self.contrary is None or self.stem is None:
            return False
        other = _distance(clause, self.stem, self.contrary, self.window)
        if other is None:
            return False
        own = _distance(clause, self.stem, self.side, self.window)
        # Not "is the other side mentioned" but "is it the nearer of the two". A clause
        # reading "tear of the posterior horn of the medial meniscus; the cruciate
        # ligaments are intact" mentions posterior, and under a presence test that was
        # enough to suppress the cruciate cue - which is the opposite of the intent,
        # since the clause does describe the ligaments. Ties go to keeping the match:
        # a clause naming both sides does mention this one.
        return own is None or other < own


# Which cue, if it sits beside the structure's stem, means the clause is about the other
# member of the pair. Only the two structures with a side-blind cue need one.
CONTRARY = {"ACL": SIDE_POSTERIOR, "MCL": SIDE_LATERAL}

ANAT_MATCH = {
    tgt: _Matcher(ANAT[tgt], *STEM_RULES[tgt], contrary=CONTRARY.get(tgt))
    for tgt in PAIRED
}
COMPARTMENT_MATCH = {
    "Medial OA": _Matcher(COMPARTMENT["Medial OA"], *STEM_RULES["Medial OA"]),
    "Lateral OA": _Matcher(COMPARTMENT["Lateral OA"], *STEM_RULES["Lateral OA"]),
    "PF OA": _Matcher(COMPARTMENT["PF OA"]),
}
DIRECT_MATCH = {
    tgt: _Matcher(_rx(rx.pattern, STEM_FRACTURE.pattern) if tgt == "Fracture" else rx)
    for tgt, rx in DIRECT.items()
}


def _severity(clause: str) -> float:
    """Weight one positive mention by how emphatic the sentence is.

    Ordered, not calibrated. A "moderate effusion" must outrank a "trace effusion" and
    both must outrank silence; the absolute numbers do not matter to AUC.
    """
    high = SEV_HIGH.search(clause) is not None
    low = SEV_LOW.search(clause) is not None
    if high and not low:
        return 1.0
    if low and not high:
        return 0.45
    return 0.75                       # unqualified mention


def _score_clauses(cls, anat_rx, path_rx=None, decoy_rx=None, context_penalty=None,
                   context_bonus=None):
    """Accumulate graded evidence over clauses for one target.

    Returns (score, confidence, n_pos, n_neg). Positives are graded by severity and by
    optional context regexes; negatives only matter when nothing positive was found,
    because reports assert normality for every structure they check.
    """
    n_pos = n_neg = n_unc = 0
    best = 0.0
    for c in cls:
        m = anat_rx.search(c)
        if not m:
            continue
        if decoy_rx is not None and decoy_rx.search(c):
            continue
        if path_rx is not None and not path_rx.search(c):
            if NORMALITY.search(c) and not NEGATION.search(c):
                n_neg += 1
            continue
        pol = _polarity(c, m.end())
        if pol == "positive":
            n_pos += 1
            w = _severity(c)
            if context_penalty is not None and context_penalty.search(c):
                w *= 0.45
            if context_bonus is not None and context_bonus.search(c):
                w = min(1.0, w * 1.35)
            best = max(best, w)
        elif pol == "negative":
            n_neg += 1
        else:
            n_unc += 1
            best = max(best, 0.30)

    if n_pos or n_unc:
        # 0.52 .. 0.95, ordered by the strongest single mention, nudged by repetition.
        score = min(0.95, 0.50 + 0.42 * best + 0.03 * min(n_pos, 3))
        conf = min(1.0, 0.55 + 0.15 * n_pos)
    elif n_neg:
        score = max(0.04, 0.20 - 0.04 * n_neg)
        conf = min(0.9, 0.45 + 0.12 * n_neg)
    else:
        score, conf = 0.28, 0.05          # silence sits above asserted-negative
    return score, conf, n_pos, n_neg


def extract(report: str) -> dict:
    """Extract twelve (score, confidence) pairs from one report."""
    cls = clauses(report)
    out = {}
    path_paired = _rx(TEAR.pattern, DEGEN.pattern, INJURY.pattern)

    for tgt in TARGETS:
        if tgt in PAIRED:
            s, c, npos, nneg = _score_clauses(cls, ANAT_MATCH[tgt], path_paired)
        elif tgt in OA_TARGETS:
            s, c, npos, nneg = _score_clauses(cls, COMPARTMENT_MATCH[tgt], OA_EVIDENCE)
        elif tgt == "Contusion":
            # Reactive subchondral oedema under a cartilage defect is osteoarthritis,
            # not a bruise. Explicit trauma wording pushes the other way.
            s, c, npos, nneg = _score_clauses(cls, DIRECT_MATCH[tgt], None, DECOY.get(tgt),
                                              context_penalty=DEGENERATIVE_MARROW,
                                              context_bonus=TRAUMA)
        else:
            s, c, npos, nneg = _score_clauses(cls, DIRECT_MATCH[tgt], None, DECOY.get(tgt))
        out[tgt] = s
        out[tgt + "__conf"] = c
        out[tgt + "__npos"] = npos
        out[tgt + "__nneg"] = nneg

    # --- cross-target corrections ------------------------------------------ #
    # A whole-joint osteoarthritis statement is evidence for every compartment that was
    # not separately assessed. Without this, "incipient OA of all three compartments"
    # scores zero on all three OA targets.
    g_hits = [c for c in cls if GLOBAL_OA.search(c) and _polarity(c, 0) == "positive"]
    if g_hits:
        gscore = 0.50 + 0.42 * max(_severity(c) for c in g_hits)
        for tgt in OA_TARGETS:
            if out[tgt + "__npos"] == 0 and out[tgt + "__nneg"] == 0:
                out[tgt] = max(out[tgt], gscore * 0.92)
                out[tgt + "__conf"] = max(out[tgt + "__conf"], 0.4)

    # Synovitis is frequently visible on the images and absent from the text, so silence
    # is weak evidence of absence here in a way it is not for other findings. Effusion is
    # its most reliable textual proxy - the two share a mechanism - so a silent synovitis
    # inherits a fraction of the effusion evidence instead of falling to the floor.
    if out["Synovitis__npos"] == 0 and out["Synovitis__nneg"] == 0:
        out["Synovitis"] = max(out["Synovitis"], 0.28 + 0.45 * (out["Effusion"] - 0.28))

    return out


# ================= 集成 API(本仓库新增,非移植代码) =================


def report_score_to_target(res: dict, tgt: str):
    """把 extract() 的一个目标结果映射为 BCE soft 目标(或 NaN)。

    n_pos>0 -> 证据分数(阳性,0.72~0.95)
    n_pos==0 且 n_neg>0 -> 证据分数(阴性,0.04~0.20)
    其余(沉默/不确定)-> NaN:该格不进损失
    """
    npos = res.get(tgt + "__npos", 0)
    nneg = res.get(tgt + "__nneg", 0)
    if npos > 0:
        return float(res[tgt])
    if nneg > 0:
        return float(res[tgt])
    return float("nan")


def _extract_cached(reports):
    return [extract(r) for r in reports]


def build_pseudo_table(train_df, report_col="Report", verbose=True):
    """从 train_df 的放射报告生成伪标签表(StudyInstanceUID + pseudo_<12>)。

    返回 DataFrame;分数列 float,无证据格为 NaN。
    官方 gold 由 load_labels 优先覆盖,此处不掺和。
    """
    reports = train_df[report_col].fillna("").tolist()
    uids = train_df["StudyInstanceUID"].tolist()
    res = _extract_cached(reports)
    rows = {}
    cnt = {t: [0, 0, 0] for t in TARGETS}   # [pos, neg, nan]
    for t in TARGETS:
        vals = []
        for r in res:
            v = report_score_to_target(r, t)
            if pd.isna(v):
                cnt[t][2] += 1
            elif v > 0.5:
                cnt[t][0] += 1
            else:
                cnt[t][1] += 1
            vals.append(v)
        rows["pseudo_" + t] = vals
    out = pd.DataFrame({"StudyInstanceUID": uids, **rows})
    if verbose:
        print(f"[标签] 报告抽取器(rsna_report_labels):{len(uids)} study,"
              f"零挂载纯 CPU;每病灶 pos/neg/无证据:")
        for t in TARGETS:
            p, n, z = cnt[t]
            print(f"  {t:18s} pos={p:5d} neg={n:5d} 无证据={z:5d}"
                  f" 覆盖={(p+n)/len(uids)*100:5.1f}%")
    return out


if __name__ == "__main__":
    # CPU sanity:python rsna_report_labels.py
    df = pd.read_csv("train.csv", nrows=200)
    tab = build_pseudo_table(df, verbose=True)
    print(tab.head(6).to_string())
')\nopen(\"/kaggle/working/rsna_report_labels.py\",\"wb\").write(base64.b64decode(\"\".join(parts)))\nprint(\"rsna_report_labels.py ->\", os.path.getsize(\"/kaggle/working/rsna_report_labels.py\")//1024, \"KB\")","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import subprocess, sys, os\nos.chdir(\"/kaggle/working\")\nprint(\"=== 运行 EXP-001 fold0 probe: rsna_v3.py --planes sagittal --epochs 3 --folds 5 --only-fold 0 --batch 8 --n-clips 2 --verbose ===\")\nr = subprocess.run([sys.executable,\"-u\",\"rsna_v3.py\",\n                    \"--planes\",\"sagittal\",\"--epochs\",\"3\",\"--folds\",\"5\",\n                    \"--only-fold\",\"0\",\"--batch\",\"8\",\"--n-clips\",\"2\",\"--verbose\"],\n                   capture_output=True, text=True)\nprint(r.stdout)\nif r.stderr: print(\"STDERR:\", r.stderr[-2500:])\nimport pandas as pd\nsp=\"/kaggle/working/submission.csv\"\nif os.path.isfile(sp):\n    sub=pd.read_csv(sp)\n    print(\"[提交文件]\", sp, sub.shape)\n    print(\"列:\", list(sub.columns))\n    print(\"NaN 总数:\", int(sub.isna().sum().sum()))\nelse:\n    print(\"[警告] submission.csv 未生成!\")\n\n# 检查 artifact 落盘\nimport glob, json\nartifact_root = \"/kaggle/working/artifacts/exp_001_5fold_sagittal\"\npatterns = [\n    f\"{artifact_root}/fold0/test_pred.npy\",\n    f\"{artifact_root}/fold0/test_uid.csv\",\n    f\"{artifact_root}/fold0/meta.json\",\n    f\"{artifact_root}/config.json\",\n    f\"{artifact_root}/fold_assignment.csv\",\n]\nfor p in patterns:\n    if os.path.exists(p):\n        size = os.path.getsize(p)\n        print(f\"[artifact] OK {p} ({size} bytes)\")\n    else:\n        print(f\"[artifact] MISSING {p}\")\n\n# 打印 meta.json 时间\nmeta_path = f\"{artifact_root}/fold0/meta.json\"\nif os.path.isfile(meta_path):\n    meta = json.load(open(meta_path, \"r\", encoding=\"utf-8\"))\n    print(\"[timing] train:\", meta.get(\"fold_train_time_sec\"), \"inference:\", meta.get(\"fold_inference_time_sec\"))\n","metadata":{},"outputs":[],"execution_count":null}]}