Download protocol/builders/common.py from zllhhhh/organic3d-benchmark: direct link, hf CLI and curl.
- Browser
- Download file 5.29 kB
-
https://huggingface.co/datasets/zllhhhh/organic3d-benchmark/resolve/main/protocol/builders/common.py
- Command line
-
hf download hf://datasets/zllhhhh/organic3d-benchmark/protocol/builders/common.py
-
curl -L -o common.py https://huggingface.co/datasets/zllhhhh/organic3d-benchmark/resolve/main/protocol/builders/common.py
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']) | |