Upload 4 files

src/02_sanitize_molecules.py

@@ -0,0 +1,61 @@
+
+import rdkit
+import pandas as pd
+import molvs
+from rdkit import Chem
+from concurrent.futures import ProcessPoolExecutor
+from tqdm import tqdm
+import pyarrow as pa
+import pyarrow.parquet as pq
+import yaml
+
+with open("parameters.yaml") as parameters_file:
+    parameters = yaml.safe_load(parameters_file)
+
+data = pd.read_csv(
+    filepath_or_buffer = "data/ro4/a2a.ro4.tsv.gz", sep = "\t", compression='gzip', header=None, names=['smiles','id','value'])
+
+# Convert the 'value' column to float, coercing errors to NaN
+data['value'] = pd.to_numeric(data['value'], errors='coerce')
+
+standardizer = molvs.Standardizer()
+fragment_remover = molvs.fragment.FragmentRemover()
+
+def sanitize_smiles(smiles_raw):
+    try:
+        mol = rdkit.Chem.MolFromSmiles(smiles_raw)
+        mol = standardizer.standardize(mol)
+        mol = fragment_remover.remove(mol)
+        smiles = rdkit.Chem.MolToSmiles(mol)
+        return smiles
+    except:
+        return None
+
+#print(data.dtypes)
+#print(data.info())
+#types_in_value = set(type(x) for x in data['value'])
+#print(types_in_value)
+#num_str = data['value'].apply(lambda x: isinstance(x, str)).sum()
+#print(f"Number of string entries in 'value': {num_str}")
+
+def parallel_sanitize(smiles_list, n_jobs=10):
+    with ProcessPoolExecutor(max_workers=n_jobs) as executor:
+        sanitized = list(tqdm(executor.map(sanitize_smiles, smiles_list), total=len(smiles_list)))
+    return sanitized
+data['clean_smiles'] = parallel_sanitize(data['smiles'].tolist(), n_jobs=10)
+
+# Drop failed rows (where sanitization failed)
+data = data[data['clean_smiles'].notnull()].copy()
+
+output_path = f"product/a2a_ro4_sanitized_{parameters['date_code']}.parquet"
+table = pa.Table.from_pandas(data[['clean_smiles', 'id', 'value']])
+pq.write_table(table, output_path, compression='snappy')
+
+
+#data['smiles'] = data['smiles'].apply(sanitize_smiles)
+
+#data.to_csv(
+ #   path_or_buf = f"product/d2_ro4_sanitized_{parameters['date_code']}.tsv",
+  #  sep = "\t",
+   # index = False)
+

src/03_split_scaffold.py

@@ -0,0 +1,82 @@
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem.Scaffolds import MurckoScaffold
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor
+from tqdm import tqdm
+import argparse
+import os
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+def get_murcko(smiles):
+    try:
+        mol = Chem.MolFromSmiles(smiles)
+        scaffold = MurckoScaffold.GetScaffoldForMol(mol)
+        return Chem.MolToSmiles(scaffold)
+    except:
+        return None
+
+def parallel_get_murcko(smiles_list, n_jobs=10):
+    with ProcessPoolExecutor(max_workers=n_jobs) as executor:
+        scaffolds = list(tqdm(executor.map(get_murcko, smiles_list), total=len(smiles_list)))
+    return scaffolds
+
+def scaffold_split(df, frac_train=0.8, frac_val=0.1, seed=42):
+    scaffold_to_indices = defaultdict(list)
+    for idx, scaffold in enumerate(df['scaffold']):
+        scaffold_to_indices[scaffold].append(idx)
+
+    scaffolds = list(scaffold_to_indices.keys())
+    rng = pd.Series(scaffolds).sample(frac=1, random_state=seed).tolist()
+
+    train_idx, val_idx, test_idx = [], [], []
+    n_total = len(df)
+    n_train, n_val = int(frac_train * n_total), int(frac_val * n_total)
+
+    for scaffold in rng:
+        indices = scaffold_to_indices[scaffold]
+        if len(train_idx) + len(indices) <= n_train:
+            train_idx.extend(indices)
+        elif len(val_idx) + len(indices) <= n_val:
+            val_idx.extend(indices)
+        else:
+            test_idx.extend(indices)
+
+    return df.iloc[train_idx], df.iloc[val_idx], df.iloc[test_idx]
+
+
+def main(args):
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    print(f"Loading data from {args.input_parquet} ...")
+    df = pd.read_parquet(args.input_parquet)
+    print(f"Loaded {len(df)} molecules")
+
+    print(f"Extracting Murcko scaffolds using {args.num_cores} cores ...")
+    df['scaffold'] = parallel_get_murcko(df[args.smiles_column], n_jobs=args.num_cores)
+
+    print("Performing scaffold split ...")
+    train_df, val_df, test_df = scaffold_split(df, frac_train=0.8, frac_val=0.1, seed=args.seed)
+
+    print(f"Train: {len(train_df)} | Val: {len(val_df)} | Test: {len(test_df)}")
+
+    print(f"Saving splits to {args.output_dir} ...")
+    train_df.to_parquet(os.path.join(args.output_dir, "train.parquet"), index=False)
+    val_df.to_parquet(os.path.join(args.output_dir, "val.parquet"), index=False)
+    test_df.to_parquet(os.path.join(args.output_dir, "test.parquet"), index=False)
+
+    print("Done!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Scaffold split virtual screening data and save as parquet.")
+    parser.add_argument("--input_parquet", type=str, required=True, help="Path to input .parquet file")
+    parser.add_argument("--output_dir", type=str, required=True, help="Output directory to save train/val/test splits")
+    parser.add_argument("--smiles_column", type=str, default="smiles", help="Column name for SMILES")
+    parser.add_argument("--num_cores", type=int, default=10, help="Number of CPU cores to use")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility")
+
+    args = parser.parse_args()
+    main(args)

src/04_fingerprints.py

@@ -0,0 +1,47 @@
+import time
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+from molfeat.calc import FPCalculator
+from molfeat.trans import MoleculeTransformer
+
+# Initialize transformer
+calc = FPCalculator("ecfp")
+mol_transf = MoleculeTransformer(calc, n_jobs=10)
+
+def transform_and_save(df, output_path, split_name="", batch_size=100000):
+    start = time.time()
+    print(f"\nStarting transformation for {split_name}...")
+
+    smiles = df['clean_smiles'].values
+    values = df['value'].values
+    all_features = []
+
+    for i in tqdm(range(0, len(smiles), batch_size), desc=f"{split_name} batches"):
+        batch_smiles = smiles[i:i + batch_size]
+        batch_fps = mol_transf(batch_smiles)
+        batch_fps = np.stack(batch_fps)
+        all_features.append(batch_fps)
+
+    features = np.vstack(all_features)
+    df_fps = pd.DataFrame(features, columns=[f"feature_{i}" for i in range(features.shape[1])])
+    df_fps["value"] = values  # Append the label
+
+    pq.write_table(pa.Table.from_pandas(df_fps), output_path)
+
+    end = time.time()
+    print(f"Finished {split_name} in {end - start:.2f} seconds.")
+
+# Process each split
+data_train = pq.read_table("product/d2_split/train.parquet").to_pandas()
+transform_and_save(data_train, "intermediate_data/d2/data_train_features.parquet", "train")
+
+data_val = pq.read_table("product/d2_split/val.parquet").to_pandas()
+transform_and_save(data_val, "intermediate_data/d2/data_val_features.parquet", "validation")
+
+data_test = pq.read_table("product/d2_split/test.parquet").to_pandas()
+transform_and_save(data_test, "intermediate_data/d2/data_test_features.parquet", "test")
+

src/05_xgboost_lowmem.py

@@ -0,0 +1,85 @@
+import pyarrow.parquet as pq
+import numpy as np
+import xgboost as xgb
+import matplotlib.pyplot as plt
+from sklearn.metrics import mean_squared_error, r2_score
+
+def load_parquet_as_numpy(path):
+    # Read Parquet file into PyArrow table
+    table = pq.read_table(path)
+
+    # Convert to pandas DataFrame
+    df = table.to_pandas()
+
+    # Drop only the label column to get features
+    X = df.drop(columns=["value"]).values.astype(np.float32)
+
+    # Extract target column
+    y = df["value"].values.astype(np.float32)
+
+    return xgb.DMatrix(X, label=y), y
+
+def load_parquet_as_dmatrix(path):
+    # Load selected columns only
+    cols = [f"feature_{i}" for i in range(2048)] + ["value"]
+    table = pq.read_table(path, columns=cols)
+
+    # Convert columns to NumPy arrays directly using Arrow
+    X = np.column_stack([table[col].to_numpy(zero_copy_only=False) for col in table.column_names if col != "value"]).astype(np.float32)
+    y = table["value"].to_numpy(zero_copy_only=False).astype(np.float32)
+
+    return xgb.DMatrix(X, label=y), y
+
+def main():
+    print("Loading training data...")
+    dtrain, y_train = load_parquet_as_dmatrix("intermediate_data/d2/data_train_features.parquet")
+
+    print("Loading validation data...")
+    dval, y_val = load_parquet_as_dmatrix("intermediate_data/d2/data_val_features.parquet")
+
+    print("Loading test data...")
+    dtest, y_test = load_parquet_as_dmatrix("intermediate_data/d2/data_test_features.parquet")
+
+    print("Training model with histogram-based tree method...")
+    params = {
+        "objective": "reg:squarederror",
+        "tree_method": "hist",
+        "max_depth": 8,
+        "eta": 0.1,
+        "nthread": 10,
+        "verbosity": 1
+    }
+
+    evals_result = {}
+    model = xgb.train(
+        params,
+        dtrain,
+        num_boost_round=300,
+        evals=[(dtrain, "train"), (dval, "eval")],
+        early_stopping_rounds=20,
+        evals_result=evals_result,
+        verbose_eval=10
+    )
+
+    # Evaluate on test set
+    y_pred = model.predict(dtest)
+    rmse = mean_squared_error(y_test, y_pred, squared=False)
+    r2 = r2_score(y_test, y_pred)
+
+    print(f"Test RMSE: {rmse:.4f}")
+    print(f"Test R^2: {r2:.4f}")
+    # Plot learning curve
+    os.makedirs("results", exist_ok=True)
+    plt.figure()
+    plt.plot(evals_result["train"]["rmse"], label="Train RMSE")
+    plt.plot(evals_result["eval"]["rmse"], label="Validation RMSE")
+    plt.xlabel("Boosting Round")
+    plt.ylabel("RMSE")
+    plt.title("XGBoost RMSE over Epochs")
+    plt.legend()
+    plt.savefig("results/d2/xgboost_d2_learning_curve.png", dpi=300)
+    print("Saved learning curve to results/xgboost_d2_learning_curve.png")
+
+if __name__ == "__main__":
+    main()
+