Datasets:
Remove CASP14 bug reproduction and old-file comparison; analysis scripts read TAPE's download directly
7bf35b0 verified | """Build SSP: protein secondary-structure data (training data plus CASP test sets), in three versions with one layout. | |
| tape TAPE's files (built by NetSurfP-2.0): train, validation, cb513, ts115, casp12; every field kept, integer labels | |
| written as letters, nothing else changed (same rows, order, ids, sequences, values). | |
| rcsb CASP12-16 test sets: the PDB entry CASP lists for each target, from RCSB; one row per PDB chain; sequence = the | |
| chain's canonical PDB sequence; mkdssp on the whole chain alone. | |
| casp CASP12-16 test sets: CASP's own public target files; one row per target; sequence = CASP's target sequence; | |
| mkdssp on the target's chain (CASP15: its domain files merged back into one chain; CASP16: first version). | |
| Labels, all versions: ss3 = H E C; ss8 = G H I B E S T C (classic DSSP); ss8_pp = ss8 plus P (DSSP 4 polyproline; rcsb | |
| and casp only). One letter per residue. As in TAPE, residues without structure are labelled C and have resolved = 0 | |
| (TAPE's `disorder`). Columns that don't apply to a version are null (e.g. tape has no coordinates; rcsb/casp have no | |
| NetSurfP features). | |
| usage: python -I scripts/build_ssp.py [--source tape rcsb casp] [--rounds 12 13 14 15 16] | |
| [--tape-splits train validation cb513 ts115 casp12] [--only T0863,...] [--out build/ssp] | |
| """ | |
| import os, re, sys, glob, json, argparse, collections | |
| sys.path.insert(0, "scripts") | |
| import pyarrow as pa, pyarrow.parquet as pq | |
| import ssp_lib as L | |
| TAPE_DIR = "data/original/tape/secondary_structure/secondary_structure" # TAPE's secondary_structure.tar.gz, extracted | |
| TAPE_FILES = {"train": "secondary_structure_train.json", "validation": "secondary_structure_valid.json", | |
| "cb513": "secondary_structure_cb513.json", "ts115": "secondary_structure_ts115.json", | |
| "casp12": "secondary_structure_casp12.json"} | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--source", nargs="+", default=["tape", "rcsb", "casp"], choices=["tape", "rcsb", "casp"]) | |
| ap.add_argument("--rounds", nargs="+", default=["12", "13", "14", "15", "16"]) | |
| ap.add_argument("--tape-splits", nargs="+", default=list(TAPE_FILES), choices=list(TAPE_FILES)) | |
| ap.add_argument("--only", default="", help="comma-separated CASP target ids (testing)") | |
| ap.add_argument("--out", default="build/ssp") | |
| args = ap.parse_args() | |
| ONLY = set(filter(None, args.only.split(","))) | |
| RCSB_CACHE = "data/original/rcsb" | |
| S8_TAPE, S3_TAPE = "GHIBESTC", "HEC" # TAPE's integer codes; with this decoding mkdssp agrees with TAPE on 99.94% (CASP12) | |
| ARCHIVE = { | |
| "12": ("casp12.targets_T0.releaseDec022016.tgz", "data/original/casp12/x/**/T*.pdb"), | |
| "13": ("casp13.targets.T.4public.tar.gz", "data/original/casp13/x/**/T*.pdb"), | |
| "14": ("casp14.targets.T.public_11.29.2020.tar.gz", "data/original/casp14/T/T*.pdb"), | |
| "15": ("casp15.targets.TS-domains.public_12.20.2022.tar.gz", "data/original/casp15/x/**/T*.pdb"), | |
| "16": ("casp16.targets_monomer.tgz", "data/original/casp16/x/**/T*.pdb"), | |
| } | |
| xyz = pa.list_(pa.list_(pa.float64())) | |
| f32, i8 = pa.list_(pa.float32()), pa.list_(pa.int8()) | |
| SCHEMA = pa.schema([ | |
| ("id", pa.string()), ("casp_targets", pa.list_(pa.string())), | |
| ("target_match", pa.list_(pa.string())), ("target_identity", pa.list_(pa.float64())), | |
| ("target_regions", pa.list_(pa.list_(pa.list_(pa.int64())))), | |
| ("sequence", pa.string()), ("ss3", pa.string()), ("ss8", pa.string()), ("ss8_pp", pa.string()), | |
| ("resolved", i8), ("valid_mask", i8), | |
| # NetSurfP-2.0's other per-residue fields, tape only (TAPE's values; all exactly representable in float32) | |
| ("rsa", f32), ("asa_max", f32), ("phi", f32), ("psi", f32), ("interface", i8), ("evolutionary", pa.list_(f32)), | |
| ("n_xyz", xyz), ("ca_xyz", xyz), ("c_xyz", xyz), ("o_xyz", xyz), ("cb_xyz", xyz), | |
| ("pdb_id", pa.string()), ("chain", pa.string()), ("method", pa.string()), ("resolution", pa.float64()), | |
| ("release_date", pa.string()), ("pdb_revision_date", pa.string()), | |
| ("source_files", pa.list_(pa.string())), ("in_tape", pa.bool_()), | |
| ]) | |
| def row(**kw): | |
| unknown = set(kw) - set(SCHEMA.names) | |
| assert not unknown, unknown | |
| return {name: kw.get(name) for name in SCHEMA.names} | |
| def write(rows, source, split, log, batch=500): | |
| """Write rows (any iterable) to {out}/{source}/{split}.parquet in row groups of `batch` rows, and the log.""" | |
| os.makedirs(f"{args.out}/{source}", exist_ok=True) | |
| os.makedirs(f"{args.out}/logs", exist_ok=True) | |
| path = f"{args.out}/{source}/{split}.parquet" | |
| n, buf = 0, [] | |
| with pq.ParquetWriter(path, SCHEMA, compression="zstd") as w: | |
| for r in rows: | |
| buf.append(r); n += 1 | |
| if len(buf) == batch: | |
| w.write_table(pa.Table.from_pylist(buf, schema=SCHEMA)); buf = [] | |
| if buf or n == 0: | |
| w.write_table(pa.Table.from_pylist(buf, schema=SCHEMA)) | |
| log["rows"] = n | |
| json.dump(log, open(f"{args.out}/logs/{source}_{split}.json", "w"), indent=1, default=str) | |
| print(f" wrote {path}: {n} rows | dropped: {len(log['dropped'])} | polyproline: {dict(log['polyproline'])}", flush=True) | |
| def dedupe(rows, log): | |
| """One row per identical sequence within a round (first by id); the rest are logged as dropped.""" | |
| seen, out = {}, [] | |
| for r in sorted(rows, key=lambda r: r["id"]): | |
| if r["sequence"] in seen: | |
| log["dropped"].append({"id": r["id"], "reason": f"same sequence as {seen[r['sequence']]}"}) | |
| continue | |
| seen[r["sequence"]] = r["id"] | |
| out.append(r) | |
| return out | |
| def new_log(source, split, **extra): | |
| return {"split": split, "source": source, "dssp": L.DSSP_VERSION if source != "tape" else None, "dropped": [], | |
| "targets": {}, "polyproline": collections.Counter(), **extra} | |
| def map_targets(rnd, log): | |
| """CASP-listed PDB code -> the entity/chain matching each target: {target: (code, chain, match, identity, regions)}.""" | |
| D = f"data/original/casp{rnd}" | |
| listed = {t: c for t, c in L.listed_targets(D).items() if c} | |
| seqs = L.target_sequences(rnd, D, sorted(listed)) | |
| info = L.entry_info({c for cs in listed.values() for c in cs}, f"{RCSB_CACHE}/entries.json") | |
| out = {} | |
| for t, codes in sorted(listed.items()): | |
| if t not in seqs: | |
| log["dropped"].append({"id": t, "reason": "no CASP sequence"}); continue | |
| best = None | |
| for code in codes: | |
| for e in (info.get(code) or {}).get("entities", []): | |
| cat, ident, regions = L.match(seqs[t], e["sequence"]) | |
| key = (ident, -["byte-identical", "contained", "pieces", "differs"].index(cat)) | |
| if best is None or key > best[0]: | |
| best = (key, code, sorted(e["chains"])[0], cat, ident, regions) | |
| if best is None: | |
| log["dropped"].append({"id": t, "reason": f"PDB entry {','.join(codes)} not available from RCSB"}); continue | |
| out[t] = best[1:] | |
| return out, seqs, info | |
| # ---------------------------------------------------------------------------------------------------------- tape | |
| def build_tape(split): | |
| path = f"{TAPE_DIR}/{TAPE_FILES[split]}" | |
| log = new_log("tape", split, source_file=TAPE_FILES[split]) | |
| by_chain, seqs = collections.defaultdict(list), {} | |
| if split == "casp12": # which CASP12 targets each TAPE chain covers | |
| targets, seqs, _ = map_targets("12", new_log("tape", split)) | |
| for t, (code, chain, *_rest) in targets.items(): | |
| by_chain[f"{code}-{chain}"].append(t) | |
| data = json.load(open(path)) | |
| def rows(): | |
| for k, r in enumerate(data): | |
| n = len(r["primary"]) | |
| assert r["protein_length"] == n and all(len(r[f]) == n for f in | |
| ("ss3", "ss8", "disorder", "valid_mask", "rsa", "asa_max", "phi", "psi", "interface", "evolutionary")), r["id"] | |
| assert all(v in (0, 1) for f in ("disorder", "valid_mask", "interface") for v in r[f]), r["id"] | |
| # TAPE labels every residue without structure (disorder = 0) as coil | |
| assert all(s8 == 7 and s3 == 2 for d, s8, s3 in zip(r["disorder"], r["ss8"], r["ss3"]) if d == 0), r["id"] | |
| ts = sorted(by_chain.get(r["id"], [])) | |
| matches = [L.match(seqs[t], r["primary"]) for t in ts] | |
| pdb, _, chain = r["id"].partition("-") | |
| yield row(id=r["id"], casp_targets=ts or None, target_match=[m[0] for m in matches] or None, | |
| target_identity=[m[1] for m in matches] or None, target_regions=[m[2] for m in matches] or None, | |
| sequence=r["primary"], ss3="".join(S3_TAPE[c] for c in r["ss3"]), | |
| ss8="".join(S8_TAPE[c] for c in r["ss8"]), | |
| resolved=[int(v) for v in r["disorder"]], valid_mask=[int(v) for v in r["valid_mask"]], | |
| rsa=r["rsa"], asa_max=r["asa_max"], phi=r["phi"], psi=r["psi"], | |
| interface=[int(v) for v in r["interface"]], evolutionary=r["evolutionary"], | |
| pdb_id=pdb or None, chain=chain or None, source_files=[TAPE_FILES[split]], in_tape=True) | |
| data[k] = None # free memory as we go (train is 1.4 GB of JSON) | |
| write(rows(), "tape", split, log) | |
| # ---------------------------------------------------------------------------------------------------------- rcsb | |
| def build_rcsb(rnd): | |
| log = new_log("rcsb", f"casp{rnd}") | |
| targets, seqs, info = map_targets(rnd, log) | |
| chains = collections.defaultdict(list) | |
| for t, (code, chain, cat, ident, regions) in targets.items(): | |
| if ONLY and t not in ONLY: | |
| continue | |
| chains[(code, chain)].append((t, cat, ident, regions)) | |
| log["targets"][t] = {"pdb": code, "chain": chain, "match": cat, "identity": ident} | |
| tape_ids = {r["id"] for r in json.load(open(f"{TAPE_DIR}/{TAPE_FILES['casp12']}"))} if rnd == "12" else set() | |
| rows = [] | |
| for (code, chain), ts in sorted(chains.items()): | |
| cif = L.download_cif(code, RCSB_CACHE) | |
| st, seq, residues = L.rcsb_chain(cif, chain) | |
| labels, pp = L.dssp(residues, st.cell) | |
| log["polyproline"].update(pp) | |
| ss3, ss8, ss8_pp, resolved = L.label_strings(len(seq), labels) | |
| xyz_ = L.coordinates(len(seq), residues) | |
| ts.sort() | |
| rows.append(row(id=f"{code}-{chain}", casp_targets=[t for t, *_ in ts], target_match=[c for _, c, _, _ in ts], | |
| target_identity=[i for _, _, i, _ in ts], target_regions=[g for *_, g in ts], | |
| sequence=seq, ss3=ss3, ss8=ss8, ss8_pp=ss8_pp, resolved=resolved, | |
| **{f"{a.lower()}_xyz": xyz_[a] for a in L.ATOMS}, | |
| pdb_id=code, chain=chain, method=info[code]["method"], resolution=info[code]["resolution"], | |
| release_date=info[code]["release_date"], pdb_revision_date=L.latest_revision(cif), | |
| source_files=[f"{code}.cif.gz"], in_tape=f"{code}-{chain}" in tape_ids)) | |
| write(dedupe(rows, log), "rcsb", f"casp{rnd}", log) | |
| # ---------------------------------------------------------------------------------------------------------- casp | |
| def base_target(name): | |
| """File name -> target id: drop CASP15 domain suffix (-D1) and CASP16 version suffix (v1, _v1).""" | |
| return re.sub(r"(_?v\d+)$", "", re.sub(r"-D\d+$", "", name)) | |
| def build_casp(rnd): | |
| D = f"data/original/casp{rnd}" | |
| archive, pattern = ARCHIVE[rnd] | |
| files = collections.defaultdict(list) | |
| for p in sorted(glob.glob(pattern, recursive=True)): | |
| files[base_target(os.path.basename(p)[:-4])].append(p) | |
| listed = L.listed_targets(D) | |
| log = new_log("casp", f"casp{rnd}", archive=archive) | |
| tape_targets = set() | |
| if rnd == "12": | |
| tape_ids = {r["id"] for r in json.load(open(f"{TAPE_DIR}/{TAPE_FILES['casp12']}"))} | |
| tape_targets = {t for t, (code, chain, *_r) in map_targets(rnd, new_log("casp", "casp12"))[0].items() | |
| if f"{code}-{chain}" in tape_ids} | |
| targets = sorted(t for t in files if not ONLY or t in ONLY) | |
| seqs = L.target_sequences(rnd, D, targets) | |
| rows = [] | |
| for t in targets: | |
| paths = files[t] | |
| variants = sorted({re.sub(r"-D\d+$", "", os.path.basename(p)[:-4]) for p in paths}) | |
| if len(variants) > 1: # several structures (versions) of one target -> the first version | |
| paths = [p for p in paths if re.sub(r"-D\d+$", "", os.path.basename(p)[:-4]) == variants[0]] | |
| log["targets"].setdefault(t, {})["versions_ignored"] = variants[1:] | |
| seq = seqs.get(t) or seqs.get(variants[0]) or seqs.get(t + "v1") | |
| if not seq: | |
| log["dropped"].append({"id": t, "reason": "no CASP sequence"}); continue | |
| st, residues, mism = L.casp_chain(paths, seq) | |
| if mism: | |
| log["dropped"].append({"id": t, "reason": f"{len(mism)} residues in CASP's file disagree with its sequence"}); continue | |
| labels, pp = L.dssp(residues, st.cell) | |
| log["polyproline"].update(pp) | |
| ss3, ss8, ss8_pp, resolved = L.label_strings(len(seq), labels) | |
| xyz_ = L.coordinates(len(seq), residues) | |
| rows.append(row(id=t, casp_targets=[t], target_match=["byte-identical"], target_identity=[1.0], | |
| target_regions=[[[1, len(seq)]]], sequence=seq, ss3=ss3, ss8=ss8, ss8_pp=ss8_pp, resolved=resolved, | |
| **{f"{a.lower()}_xyz": xyz_[a] for a in L.ATOMS}, | |
| pdb_id=",".join(listed.get(t, [])) or None, | |
| source_files=[f"{archive}:{os.path.basename(p)}" for p in paths], in_tape=t in tape_targets)) | |
| log["targets"].setdefault(t, {})["files"] = [os.path.basename(p) for p in paths] | |
| write(dedupe(rows, log), "casp", f"casp{rnd}", log) | |
| if "tape" in args.source: | |
| for split in args.tape_splits: | |
| print(f"== tape {split}", flush=True) | |
| build_tape(split) | |
| for rnd in args.rounds: | |
| for source in [s for s in ("rcsb", "casp") if s in args.source]: | |
| print(f"== {source} CASP{rnd}", flush=True) | |
| {"rcsb": build_rcsb, "casp": build_casp}[source](rnd) | |