zllhhhh's picture
ORGANIC-3D benchmark: protocol, Merlin labels, metric, leaderboard, harness
83fdf39 verified
Raw History Blame Contribute Delete
5.29 kB
"""Shared protocol definitions and text rules for the ORGANIC-3D builders (no project imports; numpy / pandas only).
The text rules (sentence split, side swap, side sentences, lobe sentences) are exact ports of the paper's code, so the
protocol files built from a local copy of each dataset are identical to the ones used for the paper's results.
"""
import json
import os
import re
HERE = os.path.dirname(os.path.abspath(__file__))
PROTOCOL = json.load(open(os.path.join(HERE, '..', 'protocol.json')))
FINDING_NAMES = [f['name'] for f in PROTOCOL['findings']]
LABEL_COLUMN = {f['name']: f['ctrate_label_column'] for f in PROTOCOL['findings']}
# ------------------------------------------------------------------ sentences
_SENT = re.compile(r'(?<=[.!?])\s+(?=[A-Z])')
def split_sentences(report, max_n=40):
report = re.sub(r'\s+', ' ', str(report or '')).strip()
report = re.sub(r'^(FINDINGS|Findings)\s*:\s*', '', report)
out = [s.strip() for s in _SENT.split(report) if len(s.strip()) > 8]
return out[:max_n]
_SIDE = re.compile(r'\b(left|right)\b', re.I)
_NEG = re.compile(r'\b(no|not|without|negative for|resolved|absent)\b', re.I)
def _case(src, word):
return word.capitalize() if src[0].isupper() else word
def lateral_swap(s):
if not _SIDE.search(s):
return None
return _SIDE.sub(lambda m: _case(m.group(0), {'left': 'right', 'right': 'left'}[m.group(0).lower()]), s)
def one_side_only(s):
"""True if the sentence names exactly one side."""
return len({w.lower() for w in _SIDE.findall(s)}) == 1
def lateral_sentences(report, max_n=6):
"""Report sentences that name exactly one side and state something present -> [(sentence, side-swapped)]."""
out = []
for s in split_sentences(report):
if one_side_only(s) and not _NEG.search(s):
sw = lateral_swap(s)
if sw and sw != s:
out.append((s, sw))
return out[:max_n]
# ------------------------------------------------------------------ lobes
LOBES = PROTOCOL['interventions']['lobe_test']['lobes']
_UML = r'(upper|middle|lower)'
_PAT = re.compile(r'\b(?:(right|left)\s+(?:lung\s+)?' + _UML + r'\s+lobes?\b|' + _UML + r'\s+lobes?\s+of\s+the\s+(right|left)\s+lung\b'
r'|lingula(?:r)?\b|\bmiddle\s+lobe\b)', re.I)
_ANY_LOBE = re.compile(r'\b(?:upper|middle|lower)\s+lobes?\b|\blingula', re.I)
_MULTI = re.compile(r'\blobes\b|\b(?:upper|middle|lower)\s*(?:and|or|,|/)\s*(?:upper|middle|lower)\b', re.I)
FINDING_WORDS = {'consolidation': r'consolidat', 'atelectasis': r'atelecta', 'nodule': r'nodul', 'opacity': r'opacit|ground[- ]glass',
'fibrotic': r'fibro|sequela', 'bronchiectasis': r'bronchiecta', 'septal': r'septal', 'emphysema': r'emphysem'}
def lobe_of(m):
t = m.group(0).lower()
if t.startswith('lingula'):
return 3
if m.group(1):
side, level = m.group(1).lower(), m.group(2).lower()
elif m.group(4):
side, level = m.group(4).lower(), m.group(3).lower()
else:
side, level = 'right', 'middle'
name = f'{side} {level} lobe'
return LOBES.index(name) if name in LOBES else None
def lobe_sentences(report, max_n=8):
"""[(sentence with a {LOBE} slot, true lobe index, finding word or '')] for present, single-lobe sentences."""
out = []
for s in split_sentences(report):
if _NEG.search(s) or re.search(r'\b(both|bilateral)\b', s, re.I):
continue
ms = list(_PAT.finditer(s))
lobes = {lobe_of(m) for m in ms} - {None}
if len(ms) != 1 or len(lobes) != 1 or len(_ANY_LOBE.findall(s)) != 1 or _MULTI.search(s):
continue
m = ms[0]
tmpl = s[:m.start()] + '{LOBE}' + s[m.end():]
word = next((k for k, p in FINDING_WORDS.items() if re.search(p, s, re.I)), '')
out.append((tmpl, lobes.pop(), word))
return out[:max_n]
def ctrate_report(findings_en, impressions_en):
"""The report text the side and lobe tests read: 'Findings: <Findings_EN> Impression: <Impressions_EN>'."""
f = '' if findings_en is None or findings_en != findings_en else str(findings_en)
i = '' if impressions_en is None or impressions_en != impressions_en else str(impressions_en)
return ('Findings: ' + f + ' Impression: ' + i).strip()
def matched_pairs(labels, scan_ids):
"""labels (N, F) float with NaN; -> DataFrame (finding, pos_scan, neg_scan): pairs with y_f = 1 / 0 and identical
labels on every other finding (NaN treated as its own value), the pairs the matched-pair AUROC averages over."""
import numpy as np
import pandas as pd
rows = []
L = np.asarray(labels, float)
for j, f in enumerate(FINDING_NAMES):
y = L[:, j]
ok = ~np.isnan(y)
others = np.delete(np.nan_to_num(L, nan=-1), j, axis=1)[ok].astype(np.int8)
ids, yy = np.asarray(scan_ids)[ok], y[ok]
groups = {}
for r, k in enumerate(map(bytes, others)):
groups.setdefault(k, []).append(r)
for g in groups.values():
g = np.asarray(g)
p, n = ids[g[yy[g] == 1]], ids[g[yy[g] == 0]]
for a in p:
for b in n:
rows.append((f, a, b))
return pd.DataFrame(rows, columns=['finding', 'pos_scan', 'neg_scan'])