Upload preprocess/qmof_preprocessor.py

data/lmdb/PMT/preprocess/qmof_preprocessor.py

@@ -0,0 +1,532 @@
+"""
+MOFTransformer Preprocessor — LMDB Edition
+
+Prepares raw MOF dataset for training by processing CIF files and packing
+the results into three LMDB files (train / val / test), one file per split.
+
+All numeric target columns from id_prop.csv are stored in the LMDB.
+The target variable to predict is chosen at training time, not here.
+
+LMDB schema per file:
+    b'__metadata__'  → pickle dict  {target_columns: [...], n_samples: int}
+    b'__keys__'      → pickle list  [cif_id, ...]
+    b'__targets__'   → pickle dict  {cif_id: {col: float_or_nan, ...}}
+    b'{cif_id}'      → pickle dict  {cif_id,
+                                     atom_num, nbr_idx, nbr_dist,
+                                     uni_idx, uni_count,
+                                     grid_header, griddata16}
+
+Author: MOFTransformer Team
+Date: 2026-03-16
+"""
+
+import os
+import sys
+import json
+import shutil
+import pickle
+import argparse
+from pathlib import Path
+from typing import Optional, Tuple, List
+
+import pandas as pd
+import numpy as np
+import lmdb
+
+# Use the pip-installed moftransformer for preprocessing (has compiled GRIDAY).
+# The local MOFTransformer copy is only used by trainer.py (patched modules).
+from moftransformer.utils.prepare_data import prepare_data
+from moftransformer.utils.install_griday import install_griday
+
+# Dummy downstream name used internally for prepare_data splitting.
+_DUMMY_DOWNSTREAM = "lmdb_split"
+
+
+# ---------------------------------------------------------------------------
+# GRIDAY helpers
+# ---------------------------------------------------------------------------
+
+def verify_griday_installation() -> None:
+    """Verify that GRIDAY is installed, install if necessary."""
+    try:
+        from moftransformer import __root_dir__
+        griday_path = os.path.join(__root_dir__, "libs/GRIDAY/scripts/grid_gen")
+        if not os.path.exists(griday_path):
+            print("GRIDAY not found. Installing GRIDAY...")
+            install_griday()
+    except ImportError as e:
+        print(f"Error importing GRIDAY: {e}")
+        print("Attempting to install GRIDAY...")
+        install_griday()
+
+
+# ---------------------------------------------------------------------------
+# CSV / CIF validation helpers
+# ---------------------------------------------------------------------------
+
+def load_all_targets(data_dir: Path) -> Tuple[pd.DataFrame, List[str]]:
+    """
+    Load id_prop.csv and return a DataFrame with all numeric target columns.
+
+    Returns
+    -------
+    Tuple[pd.DataFrame, List[str]]
+        DataFrame with columns [cif_id, col1, col2, ...] and list of target
+        column names.  Values may be NaN where data is missing.
+    """
+    id_prop_path = data_dir / "id_prop.csv"
+    if not id_prop_path.exists():
+        raise FileNotFoundError(f"id_prop.csv not found at {id_prop_path}")
+
+    df = pd.read_csv(id_prop_path)
+    if df.empty:
+        raise ValueError("id_prop.csv is empty")
+    if df.shape[1] < 2:
+        raise ValueError(
+            f"id_prop.csv must have at least 2 columns. Found {df.shape[1]}."
+        )
+
+    cif_id_col = df.columns[0]
+
+    # Detect numeric columns (excluding the cif_id column)
+    numeric_cols = []
+    for col in df.columns[1:]:
+        converted = pd.to_numeric(df[col], errors="coerce")
+        if converted.notna().sum() > 0:
+            numeric_cols.append(col)
+            df[col] = converted  # ensure numeric dtype
+
+    if not numeric_cols:
+        raise ValueError("No numeric target columns found in id_prop.csv")
+
+    result = df[[cif_id_col] + numeric_cols].copy()
+    result = result.rename(columns={cif_id_col: "cif_id"})
+    result["cif_id"] = result["cif_id"].astype(str)
+    result = result.set_index("cif_id")
+
+    print(f"Loaded {len(result)} rows from id_prop.csv")
+    print(f"Found {len(numeric_cols)} numeric target columns:")
+    for col in numeric_cols:
+        n_valid = result[col].notna().sum()
+        print(f"  {col:50s}  {n_valid}/{len(result)} non-NaN")
+
+    return result, numeric_cols
+
+
+def verify_cif_files(data_dir: Path, df: pd.DataFrame) -> pd.DataFrame:
+    """Drop rows whose CIF file is missing; return updated DataFrame."""
+    raw_dir = data_dir / "raw"
+    if not raw_dir.exists():
+        raise FileNotFoundError(f"Raw CIF directory not found at {raw_dir}")
+
+    cif_files = {f.stem for f in raw_dir.glob("*.cif")}
+    print(f"\nFound {len(cif_files)} CIF files in raw/")
+
+    valid_ids = set(df.index) & cif_files
+    missing = set(df.index) - cif_files
+    if missing:
+        print(f"Warning: {len(missing)} entries have no CIF file and will be skipped")
+
+    filtered = df.loc[list(valid_ids)].copy()
+    print(f"Valid samples: {len(filtered)}")
+
+    if len(filtered) == 0:
+        raise ValueError("No valid samples found after CIF verification.")
+    return filtered
+
+
+def create_dummy_raw_json(df: pd.DataFrame, raw_dir: Path) -> None:
+    """
+    Write raw_{DUMMY}.json  (cif_id → 0.0) so prepare_data can split the data.
+    All CIF IDs present in the DataFrame are included.
+    """
+    dummy_data = {cif_id: 0.0 for cif_id in df.index}
+    json_path = raw_dir / f"raw_{_DUMMY_DOWNSTREAM}.json"
+    with open(json_path, "w") as f:
+        json.dump(dummy_data, f, indent=2)
+    print(f"Created dummy split JSON: {json_path}  ({len(dummy_data)} entries)")
+
+
+def create_filtered_id_prop(df: pd.DataFrame, raw_dir: Path) -> None:
+    """Write a minimal id_prop.csv (cif_id, dummy_target) for prepare_data."""
+    csv_df = pd.DataFrame({"cif_id": df.index, _DUMMY_DOWNSTREAM: 0.0})
+    csv_path = raw_dir / "id_prop.csv"
+    csv_df.to_csv(csv_path, index=False)
+    print(f"Created {csv_path}")
+
+
+# ---------------------------------------------------------------------------
+# Data preparation (calls MOFTransformer's prepare_data)
+# ---------------------------------------------------------------------------
+
+def run_data_preparation(
+    raw_dir: Path,
+    processed_dir: Path,
+    train_fraction: float,
+    test_fraction: float,
+    seed: int,
+) -> None:
+    """Run MOFTransformer's prepare_data to build graph / grid embeddings."""
+    print("\nStarting data preparation with MOFTransformer utilities...")
+    print(f"  Raw directory : {raw_dir}")
+    print(f"  Processed dir : {processed_dir}")
+    print(f"  Downstream    : {_DUMMY_DOWNSTREAM}")
+
+    prepare_data(
+        root_cifs=raw_dir,
+        root_dataset=processed_dir,
+        downstream=_DUMMY_DOWNSTREAM,
+        train_fraction=train_fraction,
+        test_fraction=test_fraction,
+        seed=seed,
+    )
+
+    expected = [
+        processed_dir / f"train_{_DUMMY_DOWNSTREAM}.json",
+        processed_dir / f"val_{_DUMMY_DOWNSTREAM}.json",
+        processed_dir / f"test_{_DUMMY_DOWNSTREAM}.json",
+    ]
+    print("\nVerifying processed split files...")
+    for p in expected:
+        if p.exists() and p.stat().st_size > 0:
+            print(f"  OK  {p.name}")
+        else:
+            raise RuntimeError(
+                f"Data preparation did not produce expected file: {p}"
+            )
+    print("Data preparation completed!")
+
+
+# ---------------------------------------------------------------------------
+# LMDB packing
+# ---------------------------------------------------------------------------
+
+def _estimate_map_size(split_dir: Path, cif_ids: list) -> int:
+    """Estimate LMDB map_size from file sizes × 4 safety margin (virtual mem)."""
+    total = 0
+    for cif_id in cif_ids:
+        for ext in (".graphdata", ".griddata16", ".grid"):
+            f = split_dir / f"{cif_id}{ext}"
+            if f.exists():
+                total += f.stat().st_size
+    return max(int(total * 4), 1 << 30)
+
+
+def pack_split_to_lmdb(
+    processed_dir: Path,
+    split: str,
+    targets_df: pd.DataFrame,
+    target_columns: List[str],
+    output_path: Path,
+) -> None:
+    """
+    Pack one split into an LMDB file.
+
+    Parameters
+    ----------
+    processed_dir : Path
+        Directory produced by prepare_data.
+    split : str
+        'train', 'val', or 'test'.
+    targets_df : pd.DataFrame
+        Index = cif_id, columns = all numeric target columns (may contain NaN).
+    target_columns : List[str]
+        Ordered list of target column names to store.
+    output_path : Path
+        Destination LMDB file path.
+    """
+    json_path = processed_dir / f"{split}_{_DUMMY_DOWNSTREAM}.json"
+    if not json_path.exists():
+        raise FileNotFoundError(f"Split JSON not found: {json_path}")
+
+    with open(json_path) as f:
+        split_cif_ids: list = list(json.load(f).keys())
+
+    split_dir = processed_dir / split
+    if not split_dir.exists():
+        raise FileNotFoundError(f"Split directory not found: {split_dir}")
+
+    n = len(split_cif_ids)
+    print(f"\n  Packing '{split}' split → {output_path.name}")
+    print(f"  Samples in split: {n}")
+
+    # Build targets lookup: {cif_id: {col: float_or_nan}}
+    all_targets: dict = {}
+    for cif_id in split_cif_ids:
+        if cif_id in targets_df.index:
+            row = targets_df.loc[cif_id]
+            all_targets[cif_id] = {
+                col: float(row[col]) if pd.notna(row[col]) else float("nan")
+                for col in target_columns
+            }
+        else:
+            all_targets[cif_id] = {col: float("nan") for col in target_columns}
+
+    # Coverage stats
+    for col in target_columns[:5]:
+        n_valid = sum(1 for v in all_targets.values() if not np.isnan(v[col]))
+        print(f"    {col[:50]:50s}  {n_valid}/{n} non-NaN")
+    if len(target_columns) > 5:
+        print(f"    ... ({len(target_columns) - 5} more columns)")
+
+    map_size = _estimate_map_size(split_dir, split_cif_ids)
+    print(f"  LMDB map_size  : {map_size / 1e9:.2f} GB (virtual)")
+
+    metadata = {
+        "target_columns": target_columns,
+        "n_samples": n,
+    }
+
+    env = lmdb.open(
+        str(output_path),
+        map_size=map_size,
+        subdir=False,
+        readonly=False,
+        meminit=False,
+        map_async=True,
+    )
+
+    missing_files = []
+    written = 0
+
+    with env.begin(write=True) as txn:
+        txn.put(b"__metadata__", pickle.dumps(metadata, protocol=4))
+        txn.put(b"__keys__", pickle.dumps(split_cif_ids, protocol=4))
+        txn.put(b"__targets__", pickle.dumps(all_targets, protocol=4))
+
+        for cif_id in split_cif_ids:
+            graph_path = split_dir / f"{cif_id}.graphdata"
+            grid_path = split_dir / f"{cif_id}.grid"
+            griddata_path = split_dir / f"{cif_id}.griddata16"
+
+            missing = [p for p in (graph_path, grid_path, griddata_path) if not p.exists()]
+            if missing:
+                missing_files.extend(str(p) for p in missing)
+                continue
+
+            with open(graph_path, "rb") as fh:
+                graphdata = pickle.load(fh)
+
+            grid_header = grid_path.read_text()
+
+            with open(griddata_path, "rb") as fh:
+                griddata16 = pickle.load(fh)
+
+            sample = {
+                "cif_id": cif_id,
+                "atom_num": graphdata[1],
+                "nbr_idx": graphdata[2],
+                "nbr_dist": graphdata[3],
+                "uni_idx": graphdata[4],
+                "uni_count": graphdata[5],
+                "grid_header": grid_header,
+                "griddata16": griddata16,
+            }
+
+            txn.put(cif_id.encode(), pickle.dumps(sample, protocol=4))
+            written += 1
+
+    env.sync()
+    env.close()
+
+    if missing_files:
+        print(f"  WARNING: {len(missing_files)} files missing, samples skipped:")
+        for mf in missing_files[:10]:
+            print(f"    {mf}")
+
+    lmdb_size_mb = output_path.stat().st_size / 1e6
+    print(f"  Written {written}/{n} samples  ({lmdb_size_mb:.1f} MB on disk)")
+
+
+def pack_all_splits_to_lmdb(
+    processed_dir: Path,
+    targets_df: pd.DataFrame,
+    target_columns: List[str],
+    output_prefix: str,
+) -> dict:
+    """Pack train / val / test into separate LMDB files."""
+    prefix = Path(output_prefix)
+    prefix.parent.mkdir(parents=True, exist_ok=True)
+
+    paths = {}
+    for split in ("train", "val", "test"):
+        out = prefix.parent / f"{prefix.name}_{split}.lmdb"
+        pack_split_to_lmdb(processed_dir, split, targets_df, target_columns, out)
+        paths[split] = out
+
+    return paths
+
+
+# ---------------------------------------------------------------------------
+# Main preprocessing pipeline
+# ---------------------------------------------------------------------------
+
+def preprocess_dataset(
+    data_dir: str,
+    output_prefix: str,
+    train_fraction: float = 0.8,
+    test_fraction: float = 0.1,
+    seed: int = 42,
+) -> dict:
+    """
+    Main preprocessing function.
+
+    Reads ALL numeric columns from id_prop.csv and stores them in the LMDB.
+    The target variable is chosen at training time via --target-column.
+
+    Produces:
+        {output_prefix}_train.lmdb
+        {output_prefix}_val.lmdb
+        {output_prefix}_test.lmdb
+    """
+    print("=" * 60)
+    print("MOFTransformer Preprocessor — LMDB Edition")
+    print("=" * 60)
+
+    data_dir = Path(data_dir).resolve()
+    output_prefix = str(Path(output_prefix).resolve())
+
+    print(f"\nData directory : {data_dir}")
+    print(f"Output prefix  : {output_prefix}")
+    print(f"Train / Test   : {train_fraction} / {test_fraction}  seed={seed}")
+
+    # Step 1
+    print("\nStep 1: Verifying GRIDAY installation...")
+    verify_griday_installation()
+
+    # Step 2
+    print("\nStep 2: Loading all numeric targets from id_prop.csv...")
+    targets_df, target_columns = load_all_targets(data_dir)
+
+    # Step 3
+    print("\nStep 3: Verifying CIF files...")
+    targets_df = verify_cif_files(data_dir, targets_df)
+
+    # Step 4
+    print("\nStep 4: Setting up working directory...")
+    work_dir = data_dir / "preprocessed_work"
+    raw_dir = work_dir / "raw"
+    processed_dir = work_dir / "processed"
+
+    if work_dir.exists():
+        shutil.rmtree(work_dir)
+    for d in (work_dir, raw_dir, processed_dir):
+        d.mkdir(parents=True, exist_ok=True)
+
+    source_raw = data_dir / "raw"
+    for cif_id in targets_df.index:
+        shutil.copy2(source_raw / f"{cif_id}.cif", raw_dir / f"{cif_id}.cif")
+    print(f"Copied {len(targets_df)} CIF files")
+
+    # Step 5
+    print("\nStep 5: Creating dummy split JSON for prepare_data...")
+    create_dummy_raw_json(targets_df, raw_dir)
+    create_filtered_id_prop(targets_df, raw_dir)
+
+    # Step 6
+    print("\nStep 6: Running data preparation (graph + grid embeddings)...")
+    run_data_preparation(
+        raw_dir=raw_dir,
+        processed_dir=processed_dir,
+        train_fraction=train_fraction,
+        test_fraction=test_fraction,
+        seed=seed,
+    )
+
+    # Step 7
+    print("\nStep 7: Packing into LMDB files...")
+    lmdb_paths = pack_all_splits_to_lmdb(
+        processed_dir=processed_dir,
+        targets_df=targets_df,
+        target_columns=target_columns,
+        output_prefix=output_prefix,
+    )
+
+    # Step 8
+    print("\nStep 8: Cleaning up working directory...")
+    shutil.rmtree(work_dir)
+    print("Working directory removed")
+
+    print("\n" + "=" * 60)
+    print("Preprocessing completed!")
+    print(f"Stored {len(target_columns)} target columns:")
+    for col in target_columns:
+        print(f"  {col}")
+    print("\nOutput LMDB files:")
+    for split, path in lmdb_paths.items():
+        size_mb = path.stat().st_size / 1e6
+        print(f"  {split:5s}: {path}  ({size_mb:.1f} MB)")
+    print("=" * 60)
+
+    return lmdb_paths
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Preprocess MOF dataset and store ALL numeric targets in LMDB files. "
+            "The target variable to predict is chosen at training time."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python preprocessor.py \\
+      --data-dir      ./qmof_cif/               \\
+      --output-prefix ./output/qmof_pmt_lmdb    \\
+      --train-fraction 0.8 --test-fraction 0.1
+
+  # Produces:
+  #   ./output/qmof_pmt_lmdb_train.lmdb
+  #   ./output/qmof_pmt_lmdb_val.lmdb
+  #   ./output/qmof_pmt_lmdb_test.lmdb
+  #
+  # Each LMDB stores ALL numeric columns from id_prop.csv.
+  # Choose which target to train on via --target-column in trainer.py.
+        """,
+    )
+    parser.add_argument(
+        "--data-dir", type=str, required=True,
+        help="Dataset directory with id_prop.csv and raw/ folder",
+    )
+    parser.add_argument(
+        "--output-prefix", type=str, required=True,
+        help="Base path prefix for output LMDB files (no extension)",
+    )
+    parser.add_argument(
+        "--train-fraction", type=float, default=0.8,
+        help="Fraction for training (default: 0.8)",
+    )
+    parser.add_argument(
+        "--test-fraction", type=float, default=0.1,
+        help="Fraction for testing (default: 0.1)",
+    )
+    parser.add_argument(
+        "--seed", type=int, default=42,
+        help="Random seed (default: 42)",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_arguments()
+    try:
+        preprocess_dataset(
+            data_dir=args.data_dir,
+            output_prefix=args.output_prefix,
+            train_fraction=args.train_fraction,
+            test_fraction=args.test_fraction,
+            seed=args.seed,
+        )
+    except Exception as e:
+        print(f"\nERROR: Preprocessing failed: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()