Upload convert_odac25_aselmdb_to_is2re.py

data/original_data/ODAC25/convert_odac25_aselmdb_to_is2re.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import csv
+import math
+import pickle
+import random
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+MAP_SIZE = 512 * 1024**3
+OUTLIER_MIN = -2.0
+OUTLIER_MAX = 2.0
+SPLIT_SEED = 42
+TRAIN_FRACTION = 0.9
+COMMIT_INTERVAL = 1000
+
+
+@dataclass(frozen=True)
+class ValidSample:
+    index: int
+    sid: int
+    payload: bytes
+
+
+@dataclass
+class ConversionStats:
+    total_records_scanned: int = 0
+    records_with_fid_zero: int = 0
+    outliers_filtered: int = 0
+    valid_samples: int = 0
+    unique_sids: int = 0
+    train_samples: int = 0
+    train_unique_sids: int = 0
+    val_samples: int = 0
+    val_unique_sids: int = 0
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Convert ODAC25 ASE LMDB files into IS2RE-style LMDB datasets "
+            "compatible with fairchem LmdbDataset."
+        )
+    )
+    parser.add_argument(
+        "--src-dir",
+        required=True,
+        type=Path,
+        help="Path to a directory containing .aselmdb files.",
+    )
+    parser.add_argument(
+        "--out-dir",
+        required=True,
+        type=Path,
+        help="Directory where train/val LMDBs and logs will be written.",
+    )
+    return parser.parse_args()
+
+
+def import_dependencies() -> dict[str, Any]:
+    missing: list[str] = []
+
+    try:
+        import lmdb  # type: ignore
+    except ImportError:
+        missing.append("lmdb")
+        lmdb = None
+
+    try:
+        import torch  # type: ignore
+    except ImportError:
+        missing.append("torch")
+        torch = None
+
+    try:
+        from fairchem.core.datasets import AseDBDataset  # type: ignore
+    except ImportError:
+        missing.append("fairchem-core")
+        AseDBDataset = None
+
+    try:
+        from fairchem.core.datasets import LmdbDataset  # type: ignore
+    except ImportError:
+        LmdbDataset = None
+
+    try:
+        from torch_geometric.data import Data  # type: ignore
+    except ImportError:
+        missing.append("torch_geometric")
+        Data = None
+
+    try:
+        from tqdm import tqdm  # type: ignore
+    except ImportError:
+        missing.append("tqdm")
+        tqdm = None
+
+    if missing:
+        required = "fairchem-core lmdb torch torch_geometric numpy tqdm"
+        missing_str = ", ".join(sorted(set(missing)))
+        raise SystemExit(
+            f"Missing dependencies: {missing_str}. "
+            f"Install them with: pip install {required}"
+        )
+
+    return {
+        "lmdb": lmdb,
+        "torch": torch,
+        "AseDBDataset": AseDBDataset,
+        "LmdbDataset": LmdbDataset,
+        "Data": Data,
+        "tqdm": tqdm,
+    }
+
+
+def emit(message: str, log_file: Path) -> None:
+    print(message)
+    with log_file.open("a", encoding="utf-8") as handle:
+        handle.write(message + "\n")
+
+
+def require_sid(info: dict[str, Any], record_index: int) -> int:
+    sid = info.get("sid")
+    if sid is None:
+        raise KeyError(f"Record {record_index} is missing required info['sid'].")
+    return int(sid)
+
+
+def to_float_or_none(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        parsed = float(value)
+    except (TypeError, ValueError):
+        return None
+    if not math.isfinite(parsed):
+        return None
+    return parsed
+
+
+def scan_dataset(
+    dataset: Any,
+    outliers_csv: Path,
+    torch_module: Any,
+    data_cls: Any,
+    tqdm_cls: Any,
+) -> tuple[list[ValidSample], list[int], ConversionStats]:
+    valid_samples: list[ValidSample] = []
+    valid_sids: list[int] = []
+    stats = ConversionStats(total_records_scanned=len(dataset))
+
+    with outliers_csv.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(
+            handle,
+            fieldnames=["sid", "mof_id", "mof_type", "energy_ads_corrected"],
+        )
+        writer.writeheader()
+
+        for index in tqdm_cls(range(len(dataset)), desc="Scanning records"):
+            atoms = dataset.get_atoms(index)
+            info = dict(atoms.info)
+            fid = info.get("fid")
+
+            if fid != 0:
+                continue
+
+            stats.records_with_fid_zero += 1
+            energy_ads = to_float_or_none(info.get("energy_ads_corrected"))
+            if energy_ads is None:
+                continue
+
+            sid = require_sid(info, index)
+            if energy_ads < OUTLIER_MIN or energy_ads > OUTLIER_MAX:
+                writer.writerow(
+                    {
+                        "sid": sid,
+                        "mof_id": str(info.get("mof_name", "")),
+                        "mof_type": str(info.get("mof_type", "")),
+                        "energy_ads_corrected": energy_ads,
+                    }
+                )
+                stats.outliers_filtered += 1
+                continue
+
+            data = atoms_to_data(atoms, torch_module=torch_module, data_cls=data_cls)
+            payload = pickle.dumps(data, protocol=pickle.HIGHEST_PROTOCOL)
+            valid_samples.append(ValidSample(index=index, sid=sid, payload=payload))
+            valid_sids.append(sid)
+
+    stats.valid_samples = len(valid_samples)
+    stats.unique_sids = len(set(valid_sids))
+    return valid_samples, valid_sids, stats
+
+
+def split_sids(valid_sids: list[int]) -> tuple[set[int], set[int]]:
+    unique_sids = sorted(set(valid_sids))
+    random.seed(SPLIT_SEED)
+    random.shuffle(unique_sids)
+    split_index = int(len(unique_sids) * TRAIN_FRACTION)
+    train_sids = set(unique_sids[:split_index])
+    val_sids = set(unique_sids[split_index:])
+    return train_sids, val_sids
+
+
+class LMDBWriter:
+    def __init__(self, lmdb_module: Any, output_path: Path) -> None:
+        self.output_path = output_path
+        self.env = lmdb_module.open(
+            str(output_path),
+            map_size=MAP_SIZE,
+            subdir=False,
+            meminit=False,
+            map_async=True,
+            lock=True,
+            readahead=False,
+            create=True,
+        )
+        self.txn = self.env.begin(write=True)
+        self.count = 0
+
+    def write(self, payload: bytes) -> None:
+        self.txn.put(str(self.count).encode("ascii"), payload)
+        self.count += 1
+        if self.count % COMMIT_INTERVAL == 0:
+            self.txn.commit()
+            self.txn = self.env.begin(write=True)
+
+    def close(self) -> int:
+        self.txn.put(b"length", pickle.dumps(self.count, protocol=pickle.HIGHEST_PROTOCOL))
+        self.txn.commit()
+        self.env.sync()
+        self.env.close()
+        return self.count
+
+
+def atoms_to_data(atoms: Any, torch_module: Any, data_cls: Any) -> Any:
+    info = dict(atoms.info)
+    energy_ads = to_float_or_none(info.get("energy_ads_corrected"))
+    if energy_ads is None:
+        raise ValueError("energy_ads_corrected is required for valid samples.")
+
+    data = data_cls()
+    data.pos = torch_module.tensor(atoms.positions, dtype=torch_module.float32)
+    data.atomic_numbers = torch_module.tensor(atoms.numbers, dtype=torch_module.long)
+    data.cell = torch_module.tensor(atoms.cell[:], dtype=torch_module.float32).unsqueeze(0)
+    data.natoms = torch_module.tensor(len(atoms), dtype=torch_module.long)
+    data.pbc = torch_module.tensor(atoms.get_pbc(), dtype=torch_module.bool)
+    data.tags = torch_module.tensor(atoms.get_tags(), dtype=torch_module.long)
+    data.y_relaxed = torch_module.tensor(energy_ads, dtype=torch_module.float32)
+    data.sid = int(info["sid"])
+    data.mof_id = str(info.get("mof_name", ""))
+    data.mof_type = str(info.get("mof_type", ""))
+    data.nco2 = int(info.get("nco2", 0))
+    data.nh2o = int(info.get("nh2o", 0))
+    data.nn2 = int(info.get("nn2", 0))
+    data.no2 = int(info.get("no2", 0))
+    return data
+
+
+def write_lmdbs(
+    valid_samples: list[ValidSample],
+    train_sids: set[int],
+    val_sids: set[int],
+    train_path: Path,
+    val_path: Path,
+    lmdb_module: Any,
+    tqdm_cls: Any,
+) -> tuple[int, int]:
+    train_writer = LMDBWriter(lmdb_module, train_path)
+    val_writer = LMDBWriter(lmdb_module, val_path)
+
+    try:
+        for sample in tqdm_cls(valid_samples, desc="Writing LMDB"):
+            if sample.sid in train_sids:
+                train_writer.write(sample.payload)
+            elif sample.sid in val_sids:
+                val_writer.write(sample.payload)
+            else:
+                raise KeyError(f"SID {sample.sid} was not assigned to train or val.")
+    finally:
+        train_count = train_writer.close()
+        val_count = val_writer.close()
+
+    return train_count, val_count
+
+
+def verify_outputs(
+    out_dir: Path,
+    lmdb_module: Any,
+) -> list[str]:
+    def read_lmdb(path: Path) -> tuple[int, Any | None]:
+        env = lmdb_module.open(
+            str(path),
+            subdir=False,
+            readonly=True,
+            lock=False,
+        )
+        try:
+            with env.begin() as txn:
+                length_raw = txn.get(b"length")
+                if length_raw is None:
+                    raise RuntimeError(f"Auto-check failed: missing length key in {path}")
+                length = pickle.loads(length_raw)
+                sample = None
+                if length > 0:
+                    sample_raw = txn.get(b"0")
+                    if sample_raw is None:
+                        raise RuntimeError(f"Auto-check failed: missing sample key b'0' in {path}")
+                    sample = pickle.loads(sample_raw)
+                return length, sample
+        finally:
+            env.close()
+
+    train_len, train_sample = read_lmdb(out_dir / "odac25_is2re_train.lmdb")
+    val_len, val_sample = read_lmdb(out_dir / "odac25_is2re_val.lmdb")
+
+    if train_len == 0 and val_len == 0:
+        raise RuntimeError("Auto-check failed: both train and val datasets are empty.")
+
+    sample = train_sample if train_len > 0 else val_sample
+
+    assert hasattr(sample, "y_relaxed"), "y_relaxed missing"
+    assert hasattr(sample, "pos"), "pos missing"
+    assert OUTLIER_MIN <= sample.y_relaxed.item() <= OUTLIER_MAX, (
+        "outlier leaked into dataset!"
+    )
+
+    return [
+        f"Train size: {train_len}, Val size: {val_len}",
+        f"Sample y_relaxed: {sample.y_relaxed.item():.4f} eV",
+        "OK: dataset is compatible with fairchem LmdbDataset",
+    ]
+
+
+def format_summary(src_dir: Path, out_dir: Path, stats: ConversionStats) -> list[str]:
+    return [
+        f"Source directory:        {src_dir}",
+        f"Output directory:        {out_dir}",
+        f"Total records scanned:   {stats.total_records_scanned}",
+        f"Records with fid==0:     {stats.records_with_fid_zero}",
+        (
+            "Outliers filtered:       "
+            f"{stats.outliers_filtered}  "
+            f"(energy_ads_corrected outside [{OUTLIER_MIN:.1f}, {OUTLIER_MAX:.1f}] eV)"
+        ),
+        f"Valid samples:           {stats.valid_samples}",
+        f"Unique SIDs:             {stats.unique_sids}",
+        (
+            f"Train samples:           {stats.train_samples}  "
+            f"(unique SIDs: {stats.train_unique_sids})"
+        ),
+        (
+            f"Val samples:             {stats.val_samples}  "
+            f"(unique SIDs: {stats.val_unique_sids})"
+        ),
+    ]
+
+
+def main() -> None:
+    args = parse_args()
+    args.src_dir = args.src_dir.expanduser().resolve()
+    args.out_dir = args.out_dir.expanduser().resolve()
+
+    if not args.src_dir.is_dir():
+        raise SystemExit(f"--src-dir does not exist or is not a directory: {args.src_dir}")
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    log_file = args.out_dir / "conversion.log"
+    log_file.write_text("", encoding="utf-8")
+
+    deps = import_dependencies()
+    dataset = deps["AseDBDataset"]({"src": str(args.src_dir)})
+
+    outliers_csv = args.out_dir / "outliers.csv"
+    train_lmdb = args.out_dir / "odac25_is2re_train.lmdb"
+    val_lmdb = args.out_dir / "odac25_is2re_val.lmdb"
+
+    valid_samples, valid_sids, stats = scan_dataset(
+        dataset=dataset,
+        outliers_csv=outliers_csv,
+        torch_module=deps["torch"],
+        data_cls=deps["Data"],
+        tqdm_cls=deps["tqdm"],
+    )
+
+    train_sids, val_sids = split_sids(valid_sids)
+    stats.train_unique_sids = len(train_sids)
+    stats.val_unique_sids = len(val_sids)
+
+    train_count, val_count = write_lmdbs(
+        valid_samples=valid_samples,
+        train_sids=train_sids,
+        val_sids=val_sids,
+        train_path=train_lmdb,
+        val_path=val_lmdb,
+        lmdb_module=deps["lmdb"],
+        tqdm_cls=deps["tqdm"],
+    )
+    stats.train_samples = train_count
+    stats.val_samples = val_count
+
+    for line in format_summary(args.src_dir, args.out_dir, stats):
+        emit(line, log_file)
+
+    for line in verify_outputs(out_dir=args.out_dir, lmdb_module=deps["lmdb"]):
+        emit(line, log_file)
+
+
+if __name__ == "__main__":
+    main()