import json import math import os from pathlib import Path import numpy as np HARTREE2KCAL = 627.509474 DEFAULT_LR = 5e-5 DEFAULT_TOTAL_STEPS = 500_000 DEFAULT_WARMUP_STEPS = 10_000 DEFAULT_CLIP_THRESHOLD = 1.0 DEFAULT_BATCH_SIZE = 8 DEFAULT_EARLY_STOPPING_PATIENCE = 20 LOSS_EPS = 1e-8 SKALA_FUNCTIONAL = "skala" # Skala 1.0 CODE_ROOT = Path(__file__).resolve().parents[1] CONFIGS = CODE_ROOT / "configs" MODELS = CODE_ROOT / "models" DATA_CSV = CODE_ROOT / "data" def default_data_root(): env = os.environ.get("DATA_ROOT", "").strip() if env: return Path(env).resolve() local = CODE_ROOT / "data_pickles" if local.is_dir(): return local.resolve() return Path(".").resolve() DATA_ROOT = default_data_root() def loss_weighted_mse(pred_E, ref_E, baseline_mae, eps=LOSS_EPS): w = 1.0 / (baseline_mae + eps) return ((pred_E - ref_E) * w).pow(2) def make_adafactor_cosine(model, max_lr, warmup_steps, total_steps, clip_threshold): from torch.optim.lr_scheduler import LambdaLR from transformers import Adafactor optimizer = Adafactor( model.parameters(), lr=max_lr, scale_parameter=True, relative_step=False, warmup_init=False, clip_threshold=clip_threshold, ) def lr_lambda(step_i): step = step_i + 1 if warmup_steps > 0 and step <= warmup_steps: return step / float(warmup_steps) if total_steps <= warmup_steps: return 1.0 t = (step - warmup_steps) / float(total_steps - warmup_steps) t = min(max(t, 0.0), 1.0) return 0.5 * (1.0 + math.cos(math.pi * t)) return optimizer, LambdaLR(optimizer, lr_lambda=lr_lambda) def normalize_reaction_key(x): if x is None: return "" if isinstance(x, float) and not math.isfinite(x): return "" s = str(x).strip() if not s or s.lower() in ("nan", "none"): return "" try: f = float(s) if math.isfinite(f) and abs(f - round(f)) < 1e-9: return str(int(round(f))) except ValueError: pass return s def subset_name(name): return name.rsplit("_", 1)[0] def make_name2baseline(assets_dir=None): assets = Path(assets_dir) if assets_dir else CONFIGS / "skala_finetune_assets" with open(assets / "baseline_mae_gscdb.json") as f: gscdb_map = {str(k): float(v) for k, v in json.load(f).items()} with open(assets / "baseline_mae_msr.json") as f: msr_map = {str(k): float(v) for k, v in json.load(f).items()} with open(assets / "baseline_mae_rdb7.json") as f: rdb7_map = {str(k): float(v) for k, v in json.load(f).items()} subset2vals = {} for rxn_name, b in gscdb_map.items(): subset2vals.setdefault(subset_name(rxn_name), []).append(float(b)) subset2baseline = {k: float(np.mean(v)) for k, v in subset2vals.items()} msr_global = float(np.mean(list(msr_map.values()))) rdb7_global = float(np.mean(list(rdb7_map.values()))) return subset2baseline, msr_global, rdb7_global def name2baseline_indices(dataset, subset2baseline, msr_global, rdb7_global): missing = [] for i in range(len(dataset)): name = str(dataset[i].get("name", f"rxn_{i}")) if name.startswith(("pts_", "rts_", "rp_")): continue if "_" in name: sub = name.rsplit("_", 1)[0] if sub not in subset2baseline: missing.append(name) if missing: raise RuntimeError(f"missing baseline for {len(missing)} reactions, e.g. {missing[:5]}") idx2baseline = [] for i in range(len(dataset)): name = str(dataset[i].get("name", f"rxn_{i}")) if name.startswith(("pts_", "rts_", "rp_")): idx2baseline.append(float(rdb7_global)) elif "_" in name: idx2baseline.append(float(subset2baseline[name.rsplit("_", 1)[0]])) else: idx2baseline.append(float(msr_global)) return idx2baseline class DatasetWithBaseline: def __init__(self, base_dataset, idx2baseline): self.base_dataset = base_dataset self.idx2baseline = idx2baseline if len(self.base_dataset) != len(self.idx2baseline): raise ValueError("len mismatch") valid = [] dropped = 0 for i in range(len(self.base_dataset)): if "energy" in self.base_dataset[i]: valid.append(i) else: dropped += 1 self.indices = np.array(valid, dtype=int) self.dropped_missing_energy = dropped def __len__(self): return len(self.indices) def __getitem__(self, i): idx = int(self.indices[i]) rxn = dict(self.base_dataset[idx]) rxn["baseline_mae"] = float(self.idx2baseline[idx]) return rxn def shuffle(self, seed=None): rng = np.random.default_rng(seed) rng.shuffle(self.indices)