| import argparse |
| import os |
| import random |
| import re |
|
|
| TCGA_ID_RE = re.compile(r"(TCGA-[A-Z0-9]{2}-[A-Z0-9]+)") |
| DX_TOKEN_RE = re.compile(r"(?:^|-)DX\d*(?=[\-.]|$)") |
| TS_TOKEN_RE = re.compile(r"(?:^|-)TS[A-Za-z0-9]*(?=[\-.]|$)") |
| DX_NUM_RE = re.compile(r"(?:^|-)DX(\d*)(?=[\-.]|$)") |
|
|
|
|
| def extract_case_id(name): |
| m = TCGA_ID_RE.search(name) |
| return m.group(1) if m else None |
|
|
|
|
| def is_dx_item(name): |
| if TS_TOKEN_RE.search(name): |
| return False |
| return DX_TOKEN_RE.search(name) is not None |
|
|
|
|
| def list_items(path): |
| items = [] |
| if os.path.isdir(path): |
| for n in os.listdir(path): |
| if n.startswith('.'): |
| continue |
| items.append(n) |
| else: |
| with open(path, 'r', encoding='utf-8', errors='ignore') as f: |
| for line in f: |
| line = line.strip() |
| if not line: |
| continue |
| items.append(line) |
| return items |
|
|
|
|
| def collect_feature_items(path): |
| items = list_items(path) |
| case_to_items = {} |
| for n in items: |
| if os.path.isdir(path): |
| if not n.endswith('.pt'): |
| continue |
| if not is_dx_item(n): |
| continue |
| cid = extract_case_id(n) |
| if not cid: |
| continue |
| case_to_items.setdefault(cid, []).append(n) |
| for k in list(case_to_items.keys()): |
| case_to_items[k].sort() |
| return case_to_items |
|
|
|
|
| def collect_label_cases(path): |
| items = list_items(path) |
| cases = set() |
| for n in items: |
| if os.path.isdir(path): |
| p = os.path.join(path, n) |
| if not os.path.isdir(p): |
| continue |
| cid = extract_case_id(n) |
| if cid: |
| cases.add(cid) |
| return cases |
|
|
|
|
| def dx_rank(name): |
| m = DX_NUM_RE.search(name) |
| if not m: |
| return 50 |
| num = m.group(1) |
| if num == '1': |
| return 1 |
| if num == '2': |
| return 2 |
| if num == '': |
| return 10 |
| try: |
| return 10 + int(num) |
| except ValueError: |
| return 50 |
|
|
|
|
| def choose_best_item(items): |
| if not items: |
| return None |
| return sorted(items, key=lambda x: (dx_rank(x), x))[0] |
|
|
|
|
| def write_csv(train_items, val_items, test_items, out_path): |
| max_len = max(len(train_items), len(val_items), len(test_items)) |
| with open(out_path, 'w', encoding='utf-8') as f: |
| f.write(',train,val,test\n') |
| for i in range(max_len): |
| t = train_items[i] if i < len(train_items) else '' |
| v = val_items[i] if i < len(val_items) else '' |
| te = test_items[i] if i < len(test_items) else '' |
| t = os.path.splitext(t)[0] |
| v = os.path.splitext(v)[0] |
| te = os.path.splitext(te)[0] |
| f.write(f"{i},{t},{v},{te}\n") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument('--feature_source', type=str, default='/mnt/datadisk0/TCGA_pt/STAD_UNI') |
| ap.add_argument('--label_source', type=str, default='/mnt/datadisk0/datasets/TCGA-STAD') |
| ap.add_argument('--output_csv', type=str, default='/mnt/datadisk0/data_process/splits_STAD.csv') |
| ap.add_argument('--seed', type=int, default=42) |
| args = ap.parse_args() |
|
|
| features_map = collect_feature_items(args.feature_source) |
| label_cases = collect_label_cases(args.label_source) |
| common_cases = sorted(set(features_map.keys()) & label_cases) |
|
|
| random.seed(args.seed) |
| random.shuffle(common_cases) |
|
|
| total = len(common_cases) |
| n_train = int(total * 0.8) |
| n_val = int(total * 0.1) |
| n_test = total - n_train - n_val |
|
|
| train_cases = common_cases[:n_train] |
| val_cases = common_cases[n_train:n_train + n_val] |
| test_cases = common_cases[n_train + n_val:] |
|
|
| train_items = [] |
| val_items = [] |
| test_items = [] |
|
|
| for c in train_cases: |
| item = choose_best_item(features_map.get(c, [])) |
| if item: |
| train_items.append(item) |
| for c in val_cases: |
| item = choose_best_item(features_map.get(c, [])) |
| if item: |
| val_items.append(item) |
| for c in test_cases: |
| item = choose_best_item(features_map.get(c, [])) |
| if item: |
| test_items.append(item) |
|
|
| write_csv(train_items, val_items, test_items, args.output_csv) |
|
|
| print('Feature source:', args.feature_source) |
| print('Label source:', args.label_source) |
| print('Common cases:', total) |
| print('Train cases:', len(train_cases)) |
| print('Val cases:', len(val_cases)) |
| print('Test cases:', len(test_cases)) |
| print('Train items:', len(train_items)) |
| print('Val items:', len(val_items)) |
| print('Test items:', len(test_items)) |
| print('Output CSV:', args.output_csv) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
