File size: 9,237 Bytes
82a7f64 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | """Generate a bounded research artifact. No clinical scoring or remote-code loading."""
import argparse
import datetime
import hashlib
import json
import platform
from pathlib import Path
from urllib.request import urlopen
import numpy as np
import rdkit
import torch
import transformers
from rdkit import Chem, RDLogger
from rdkit.Chem import Crippen, Descriptors, QED, rdMolDescriptors
from rdkit.Chem.Draw import rdMolDraw2D
from rdkit.Contrib.SA_Score import sascorer
from transformers import AutoModelForCausalLM, AutoTokenizer
ROOT = Path(__file__).resolve().parents[1]
MODEL = "jarod0411/linkerGPT"
REVISION = "3d1bab27707849cd8b6c0fe1cda9d6de48625b1d"
WEIGHTS_SHA = "2cb13f1561df5c89fb2e7f8d25f2280edae9b76430ab03d1a1d11dec1e6dc38d"
SEED = 41
COUNT = 12
MAX_TOKENS = 96
CONTROL_SMILES = [
("Two-handle PEG fragment", "[*:1]CCOCCOCC[*:2]"),
("Two-handle amide fragment", "[*:1]CCC(=O)NCCC[*:2]"),
("Single-handle control", "[*:1]CCOCC"),
("No-handle proxy control", "CCOC(=O)c1ccccc1"),
("Invalid SMILES control", "C1CC"),
("Disconnected control", "[*:1]CC.OCC[*:2]"),
("Repeated attachment-map control", "[*:1]CCOCC[*:1]"),
("Equivalent PEG representation", "[*:2]CCOCCOCC[*:1]"),
]
def sha(data):
return hashlib.sha256(data).hexdigest()
def describe(smiles, identifier, name, origin, nll=None):
mol = Chem.MolFromSmiles(smiles)
result = dict(id=identifier, name=name, origin=origin, smiles=smiles,
adapter_trial=origin == "checkpoint_sample", completed_with_eos=None,
canonical_smiles=None, valid=False, connected=False,
attachment_points=0, has_two_mapped_attachments=False,
descriptors=None, mean_token_nll=nll, proxy_reward=None,
depiction_svg=None)
if mol is None or mol.GetNumAtoms() == 0:
return result
wildcards = [a for a in mol.GetAtoms() if a.GetAtomicNum() == 0]
connected = len(Chem.GetMolFrags(mol)) == 1
mapped = (len(wildcards) == 2 and {a.GetAtomMapNum() for a in wildcards} == {1, 2}
and all(a.GetDegree() == 1 for a in wildcards) and connected)
capped = Chem.ReplaceSubstructs(mol, Chem.MolFromSmarts("[#0]"),
Chem.MolFromSmiles("[H]"), replaceAll=True)[0]
capped = Chem.RemoveHs(capped)
Chem.SanitizeMol(capped)
values = dict(molecular_weight=Descriptors.MolWt(capped),
logp=Crippen.MolLogP(capped), tpsa=rdMolDescriptors.CalcTPSA(capped),
qed=QED.qed(capped), sa_score=sascorer.calculateScore(capped))
# Same clipped expression as the published RL script, applied to capped fragments.
reward = float(np.clip(values["qed"] + 1 - values["sa_score"] / 10
- 0.1 * rdMolDescriptors.CalcNumRings(capped), 0, 1))
drawer = rdMolDraw2D.MolDraw2DSVG(300, 170)
drawer.DrawMolecule(mol)
drawer.FinishDrawing()
result.update(canonical_smiles=Chem.MolToSmiles(mol), valid=True,
connected=connected, attachment_points=len(wildcards),
has_two_mapped_attachments=mapped, descriptors=values,
proxy_reward=reward, depiction_svg=drawer.GetDrawingText())
return result
def structure(metadata_file):
raw = metadata_file.read_bytes()
matches = [r for r in json.loads(raw) if r["uniprotAccession"] == "P04626"
and r["entryId"] == "AF-P04626-F1" and r["latestVersion"] == 6]
if len(matches) != 1:
raise ValueError("Canonical HER2 structure identity mismatch")
r = matches[0]
url = "https://alphafold.ebi.ac.uk/files/AF-P04626-F1-confidence_v6.json"
if r["plddtDocUrl"] != url or r["isComplex"]:
raise ValueError("Unexpected structure source")
confidence_file = metadata_file.with_name('her2_alphafold_confidence.json')
if confidence_file.exists():
confidence = confidence_file.read_bytes()
else:
confidence = urlopen(url, timeout=30).read()
confidence_file.write_bytes(confidence)
data = json.loads(confidence)
scores = data["confidenceScore"]
if (len(scores) != 1255 or len(r["sequence"]) != 1255
or not all(isinstance(s, (float, int)) and np.isfinite(s) and 0 <= s <= 100 for s in scores)):
raise ValueError("Invalid pLDDT values")
return dict(provider="AlphaFold DB", method=r["toolUsed"], uniprot_id="P04626",
entry_id="AF-P04626-F1", version=6, model_created_at=r["modelCreatedDate"],
metadata_url="https://alphafold.ebi.ac.uk/api/prediction/P04626",
confidence_url=url, metadata_sha256=sha(raw), confidence_sha256=sha(confidence),
sequence_sha256=sha(r["sequence"].encode()), residue_count=1255,
mean_plddt=float(np.mean(scores)), below_50_fraction=sum(s < 50 for s in scores) / 1255,
plddt=scores, license="CC-BY-4.0", role="target_monomer_only")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--cache", type=Path, required=True, help="Pinned local HF snapshot directory")
parser.add_argument("--structure-metadata", type=Path, default=ROOT / 'data/model_sources/her2_alphafold_metadata.json')
parser.add_argument("--output", type=Path, default=ROOT / "data/model_observations.json")
args = parser.parse_args()
if sha((args.cache / "model.safetensors").read_bytes()) != WEIGHTS_SHA:
raise ValueError("Model weights mismatch")
torch.set_num_threads(4)
torch.manual_seed(SEED)
torch.use_deterministic_algorithms(True)
RDLogger.DisableLog("rdApp.warning")
RDLogger.DisableLog("rdApp.error")
tokenizer = AutoTokenizer.from_pretrained(args.cache, local_files_only=True, trust_remote_code=False)
if (len(tokenizer), tokenizer.bos_token_id, tokenizer.eos_token_id, tokenizer.pad_token_id) != (3154, 3152, 0, 3153):
raise ValueError("Unexpected tokenizer")
model = AutoModelForCausalLM.from_pretrained(args.cache, local_files_only=True,
use_safetensors=True, trust_remote_code=False).eval()
start = torch.full((COUNT, 1), tokenizer.bos_token_id, dtype=torch.long)
with torch.inference_mode():
tokens = model.generate(start, do_sample=True, max_new_tokens=MAX_TOKENS,
temperature=1.0, top_k=50, top_p=0.95,
bos_token_id=3152, eos_token_id=0, pad_token_id=3153,
suppress_tokens=list(range(len(tokenizer), model.config.vocab_size)))
controls = [describe(s, f"control-{i:02}", n, "synthetic_control")
for i, (n, s) in enumerate(CONTROL_SMILES, 1)]
samples = []
for i, row in enumerate(tokens, 1):
smiles = tokenizer.decode(row[1:], skip_special_tokens=True).strip()
if len(smiles) > 1024:
raise ValueError("Generated sample exceeds limit")
encoded = tokenizer(tokenizer.bos_token + smiles + tokenizer.eos_token, return_tensors="pt")
with torch.inference_mode():
nll = float(model(**encoded, labels=encoded.input_ids).loss)
observation = describe(smiles, f"sample-{i:02}", f"Adapter trial {i}", "checkpoint_sample", nll)
observation["completed_with_eos"] = 0 in row[1:].tolist()
samples.append(observation)
result = dict(version="conjugate-models-1", generated_at=datetime.datetime.now(datetime.timezone.utc).isoformat().replace("+00:00", "Z"),
generator_sha256=sha(Path(__file__).read_bytes()),
linker_model=dict(id=MODEL, revision=REVISION, weights_sha256=WEIGHTS_SHA,
tokenizer_sha256=sha((args.cache / "tokenizer.json").read_bytes()),
config_sha256=sha((args.cache / "config.json").read_bytes()),
input_sha256=sha(json.dumps({"input_ids": start.tolist()}, separators=(',', ':')).encode()),
dtype=str(next(model.parameters()).dtype).removeprefix('torch.'),
license="not_declared", paper_checkpoint_equivalence="not_verified",
device="cpu", invocation_kind="unconditioned_format_probe", seed=SEED, sample_count=COUNT, max_new_tokens=MAX_TOKENS,
temperature=1, top_k=50, top_p=0.95, bos_token_id=3152, eos_token_id=0,
pad_token_id=3153, suppressed_unmapped_tokens=True, provider_requests=0, retries=0),
tools=dict(python=platform.python_version(), torch=torch.__version__,
transformers=transformers.__version__, rdkit=rdkit.__version__, numpy=np.__version__),
molecules=controls + samples, structure=structure(args.structure_metadata))
args.output.write_text(json.dumps(result, indent=2, allow_nan=False) + "\n")
valid = sum(s["valid"] for s in samples)
print(json.dumps(dict(samples=COUNT, valid=valid, invalid=COUNT-valid,
mapped_attachment_pass=sum(s["has_two_mapped_attachments"] for s in samples))))
if __name__ == "__main__":
main()
|