D4CMPP2 0.4.0__py3-none-any.whl

D4CMPP2/grid_search.py

@@ -0,0 +1,259 @@
+"""Compatibility-preserving exhaustive grid search."""
+
+import copy
+import csv
+import itertools
+import json
+import os
+import traceback
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+from D4CMPP2._main import check_args, run, set_config
+from D4CMPP2.src.utils import supportfile_saver
+from D4CMPP2.src.utils.output import get_output
+
+
+GRID_SUMMARY_SCHEMA_VERSION = 1
+
+
+def grid_generator(param_grid):
+    if not isinstance(param_grid, dict) or not param_grid:
+        raise ValueError(
+            "hyperparameters must be a non-empty mapping of parameter names to "
+            "non-empty value sequences."
+        )
+    invalid = {
+        key: values
+        for key, values in param_grid.items()
+        if (
+            not isinstance(key, str)
+            or not key.strip()
+            or isinstance(values, (str, bytes))
+            or not isinstance(values, (list, tuple))
+            or not values
+        )
+    }
+    if invalid:
+        raise ValueError(
+            "Each hyperparameter key must be a non-empty string and each value "
+            f"must be a non-empty list or tuple; invalid entries: {invalid!r}."
+        )
+    keys, values = zip(*param_grid.items())
+    for combination in itertools.product(*values):
+        yield dict(zip(keys, combination))
+
+
+config0 = {
+    "data": None,
+    "target": [],
+    "network": None,
+    "scaler": "standard",
+    "optimizer": "Adam",
+    "max_epoch": 2000,
+    "batch_size": 256,
+    "learning_rate": 0.001,
+    "weight_decay": 0.0005,
+    "lr_patience": 40,
+    "early_stopping_patience": 100,
+    "device": "cuda:0",
+    "pin_memory": False,
+}
+
+
+def _grid_suffix(parameters):
+    return "".join(f"_{key},{value}" for key, value in parameters.items())
+
+
+def _unique_trial_path(base_path, parameters, trial_number, used_paths):
+    candidate = f"{base_path}{_grid_suffix(parameters)}"
+    normalized = os.path.normcase(os.path.abspath(candidate))
+    if normalized not in used_paths and not os.path.exists(candidate):
+        used_paths.add(normalized)
+        return candidate
+
+    candidate = f"{candidate}__trial_{trial_number:04d}"
+    normalized = os.path.normcase(os.path.abspath(candidate))
+    suffix = 1
+    while normalized in used_paths or os.path.exists(candidate):
+        candidate = (
+            f"{base_path}{_grid_suffix(parameters)}"
+            f"__trial_{trial_number:04d}_{suffix}"
+        )
+        normalized = os.path.normcase(os.path.abspath(candidate))
+        suffix += 1
+    used_paths.add(normalized)
+    return candidate
+
+
+def _atomic_json(path, value):
+    staging = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp")
+    try:
+        staging.write_text(
+            json.dumps(value, indent=2, sort_keys=True, default=repr),
+            encoding="utf-8",
+        )
+        os.replace(staging, path)
+    finally:
+        if staging.exists():
+            staging.unlink()
+
+
+def _write_summary(summary, base_path):
+    base = Path(base_path)
+    json_path = base.parent / f"{base.name}_grid_search.json"
+    csv_path = base.parent / f"{base.name}_grid_search.csv"
+    json_path.parent.mkdir(parents=True, exist_ok=True)
+    summary["summary_json"] = str(json_path)
+    summary["summary_csv"] = str(csv_path)
+    _atomic_json(json_path, summary)
+
+    fieldnames = [
+        "trial",
+        "status",
+        "model_path",
+        "parameters",
+        "started_at",
+        "ended_at",
+        "duration_seconds",
+        "error_type",
+        "error_message",
+    ]
+    staging = csv_path.with_name(f".{csv_path.name}.{uuid.uuid4().hex}.tmp")
+    try:
+        with open(staging, "w", encoding="utf-8", newline="") as stream:
+            writer = csv.DictWriter(stream, fieldnames=fieldnames)
+            writer.writeheader()
+            for trial in summary["trials"]:
+                row = {key: trial.get(key) for key in fieldnames}
+                row["parameters"] = json.dumps(
+                    trial["parameters"], sort_keys=True, default=repr
+                )
+                writer.writerow(row)
+        os.replace(staging, csv_path)
+    finally:
+        if staging.exists():
+            staging.unlink()
+    return str(json_path), str(csv_path)
+
+
+def grid_search(hyperparameters, **kwargs):
+    """Run every parameter combination and write a JSON/CSV status summary.
+
+    The historical return value remains ``None``. Hyperparameter values override
+    both base arguments and registry defaults for each isolated trial.
+    """
+    combinations = list(grid_generator(copy.deepcopy(hyperparameters)))
+    base_kwargs = copy.deepcopy(config0)
+    base_kwargs.update(copy.deepcopy(kwargs))
+    base_config = set_config(**check_args(**base_kwargs))
+    output = get_output(base_config)
+    base_model_path = base_config["MODEL_PATH"]
+    started = datetime.now(timezone.utc)
+    summary = {
+        "grid_summary_schema_version": GRID_SUMMARY_SCHEMA_VERSION,
+        "status": "running",
+        "started_at": started.isoformat(),
+        "base_model_path": base_model_path,
+        "hyperparameters": copy.deepcopy(hyperparameters),
+        "trial_count": len(combinations),
+        "completed_count": 0,
+        "failed_count": 0,
+        "interrupted_count": 0,
+        "trials": [],
+    }
+    used_paths = set()
+    interrupted_at = None
+
+    for trial_number, parameters in enumerate(combinations, start=1):
+        trial_started = datetime.now(timezone.utc)
+        trial_config = copy.deepcopy(base_config)
+        trial_config.update(copy.deepcopy(parameters))
+        trial_path = _unique_trial_path(
+            base_model_path, parameters, trial_number, used_paths
+        )
+        trial_config["MODEL_PATH"] = trial_path
+        trial = {
+            "trial": trial_number,
+            "status": "running",
+            "parameters": copy.deepcopy(parameters),
+            "model_path": trial_path,
+            "started_at": trial_started.isoformat(),
+        }
+        summary["trials"].append(trial)
+        _write_summary(summary, base_model_path)
+        try:
+            Path(trial_path).mkdir(parents=True, exist_ok=False)
+            supportfile_saver.save_additional_files(trial_config)
+            result_path = run(trial_config)
+            trial["status"] = "completed"
+            trial["result_path"] = result_path
+            summary["completed_count"] += 1
+        except KeyboardInterrupt:
+            trial["status"] = "interrupted"
+            summary["interrupted_count"] += 1
+            interrupted_at = trial_number
+            output.error(
+                f"[Grid Search] Interrupted during trial {trial_number}."
+            )
+            break
+        except Exception as exc:
+            trial["status"] = "failed"
+            trial["error_type"] = type(exc).__name__
+            trial["error_message"] = str(exc)[:2000]
+            trial["traceback"] = traceback.format_exc()[-8000:]
+            summary["failed_count"] += 1
+            output.error(
+                f"[Grid Search] Trial {trial_number} failed:\n"
+                f"{trial['traceback']}"
+            )
+        finally:
+            ended = datetime.now(timezone.utc)
+            trial["ended_at"] = ended.isoformat()
+            trial["duration_seconds"] = (
+                ended - trial_started
+            ).total_seconds()
+            _write_summary(summary, base_model_path)
+
+    if interrupted_at is not None:
+        for trial_number, parameters in enumerate(
+            combinations[interrupted_at:], start=interrupted_at + 1
+        ):
+            summary["trials"].append(
+                {
+                    "trial": trial_number,
+                    "status": "not_started",
+                    "parameters": copy.deepcopy(parameters),
+                    "model_path": None,
+                    "error_type": None,
+                    "error_message": "Grid search was interrupted before this trial started.",
+                }
+            )
+
+    ended = datetime.now(timezone.utc)
+    if summary["interrupted_count"]:
+        summary["status"] = "interrupted"
+    elif summary["failed_count"]:
+        summary["status"] = (
+            "failed" if summary["completed_count"] == 0 else "completed_with_failures"
+        )
+    else:
+        summary["status"] = "completed"
+    summary["ended_at"] = ended.isoformat()
+    summary["duration_seconds"] = (ended - started).total_seconds()
+    json_path, csv_path = _write_summary(summary, base_model_path)
+    output.always(
+        "[Grid Search] Run complete: "
+        f"completed={summary['completed_count']}, "
+        f"failed={summary['failed_count']}, "
+        f"interrupted={summary['interrupted_count']}. "
+        f"JSON: {json_path!r}; CSV: {csv_path!r}."
+    )
+    return None
+
+
+if __name__ == "__main__":
+    raise SystemExit(
+        "Call grid_search(hyperparameters, **training_kwargs) from Python or D4CMPP2."
+    )

D4CMPP2/network_refer.yaml

@@ -0,0 +1,160 @@
+
+GCN:
+  name: "GCN1"
+  network: GCN_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "GCN"
+  version: "2.0"
+
+GCNwS:
+  name: "GCN1withSolvent"
+  network: GCNwithSolv_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager_withSolv
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "GCN"
+  version: "2.0"
+
+MPNN:
+  name: "MPNN1"
+  network: MPNN_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "MPNN"
+  version: "2.0"
+  
+MPNNwS:
+  name: "MPNN1withSolvent"
+  network: MPNNwithSolv_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager_withSolv
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "MPNN"
+  version: "2.0"
+
+DMPNN:
+  name: "DMPNN1"
+  network: DMPNN_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "DMPNN"
+  version: "2.0"
+  
+DMPNNwS:
+  name: "DMPNN1withSolvent"
+  network: DMPNNwithSolv_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager_withSolv
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "DMPNN"
+  version: "2.0"
+
+
+
+AFP:
+  name: "AFP1"
+  network: AFP_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "AFP"
+  version: "2.0"
+  
+AFPwS:
+  name: "AFP1"
+  network: AFPwithSolv_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager_withSolv
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "AFP"
+  version: "2.0"
+  
+GAT:
+  name: "GAT1"
+  network: GAT_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "GAT"
+  version: "2.0"
+
+GATwS:
+  name: "GAT1withSolvent"
+  network: GATwithSolv_model
+  data_manager_module: MolDataManager
+  data_manager_class: MolDataManager_withSolv
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: TrainManager
+  train_manager_class: Trainer
+  description: "GAT"
+  version: "2.0"
+
+
+ISAT:
+  name: "ISAT1"
+  network: ISAT_model
+  data_manager_module: ISADataManager
+  data_manager_class: ISADataManager
+  network_manager_module: ISANetworkManager
+  network_manager_class: ISANetworkManager
+  train_manager_module: ISATrainManager
+  train_manager_class: ISATrainer
+  description: "IGS"
+  version: "2.0"
+    
+
+ISATPN:
+  name: "ISATPN"
+  network: ISATPN_model
+  data_manager_module: ISADataManager
+  data_manager_class: ISADataManager
+  network_manager_module: ISANetworkManager
+  network_manager_class: ISANetworkManager
+  train_manager_module: ISATrainManager
+  train_manager_class: ISATrainer
+  description: "ISATPN"
+  version: "2.0"
+    
+GC:
+  name: "GC1"
+  network: GC_model
+  data_manager_module: ISADataManager
+  data_manager_class: ISADataManager
+  network_manager_module: NetworkManager
+  network_manager_class: NetworkManager
+  train_manager_module: ISATrainManager
+  train_manager_class: ISATrainer
+  description: "GC"
+  version: "2.0"

D4CMPP2/networks/AFP_model.py

@@ -0,0 +1,72 @@
+import torch.nn as nn
+
+from D4CMPP2.networks.base import (
+    InputContract,
+    MolecularNetwork,
+    STANDARD_GRAPH_HYPERPARAMETERS,
+    STANDARD_GRAPH_OPTIMIZATION_SPACE,
+)
+from D4CMPP2.networks.src.AFP import  AttentiveFP
+from D4CMPP2.networks.src.Linear import Linears
+
+
+class AFP(MolecularNetwork):
+    """Attentive fingerprint network with optional atom-attention output."""
+
+    model_name = "afp"
+    required_config = ("node_dim", "edge_dim", "target_dim")
+    input_contract = InputContract(
+        required=(
+            "compound_graphs",
+            "compound_node_feature",
+            "compound_edge_feature",
+        ),
+        optional=("get_score",),
+    )
+    hyperparameters = STANDARD_GRAPH_HYPERPARAMETERS
+    default_optimization_space = STANDARD_GRAPH_OPTIMIZATION_SPACE
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        linear_layers = self.config["linear_layers"]
+        dropout = self.config["dropout"]
+        hidden_dim = self.config["hidden_dim"]
+
+        self.embedding_node_lin = nn.Linear(self.config["node_dim"], hidden_dim, bias=True)
+        self.embedding_edge_lin = nn.Linear(self.config["edge_dim"], hidden_dim, bias=True)
+
+        self.AttentiveFP = AttentiveFP(self.config)
+        self.Linears = Linears(hidden_dim,self.config["target_dim"], nn.ReLU(), linear_layers, dropout, False, False, True) 
+        
+
+    def forward(self, **kwargs):
+        graph = kwargs.get('compound_graphs', kwargs.get('graph'))
+        node_feats = kwargs.get('compound_node_feature', kwargs.get('node_feats'))
+        edge_feats = kwargs.get('compound_edge_feature', kwargs.get('edge_feats'))
+        missing = [
+            name
+            for name, value in {
+                "compound_graphs": graph,
+                "compound_node_feature": node_feats,
+                "compound_edge_feature": edge_feats,
+            }.items()
+            if value is None
+        ]
+        if missing:
+            raise ValueError(f"AFP input is missing required fields {missing!r}.")
+
+        node = self.embedding_node_lin(node_feats)
+        edge = self.embedding_edge_lin(edge_feats)
+
+        super_node, att_w = self.AttentiveFP(graph, node, edge)
+
+        output = self.Linears(super_node)
+        
+        if kwargs.get('get_score',False):
+            return {'prediction':output, 'positive':att_w}
+        
+        return output
+
+
+network = AFP

D4CMPP2/networks/AFPwithSolv_model.py

@@ -0,0 +1,72 @@
+import torch.nn as nn
+
+from D4CMPP2.networks.base import (
+    InputContract,
+    MolecularNetwork,
+    STANDARD_SOLVENT_HYPERPARAMETERS,
+    STANDARD_SOLVENT_OPTIMIZATION_SPACE,
+)
+from D4CMPP2.networks.src.AFP import  AttentiveFP
+from D4CMPP2.networks.src.SolventLayer import SolventLayer
+
+class SolventAFP(MolecularNetwork):
+    """Attentive fingerprint compound encoder with a solvent branch."""
+
+    model_name = "afp_solvent"
+    required_config = ("node_dim", "edge_dim", "target_dim")
+    input_contract = InputContract(
+        required=(
+            "compound_graphs",
+            "compound_node_feature",
+            "compound_edge_feature",
+            "solvent_graphs",
+            "solvent_node_feature",
+        )
+    )
+    hyperparameters = STANDARD_SOLVENT_HYPERPARAMETERS
+    default_optimization_space = STANDARD_SOLVENT_OPTIMIZATION_SPACE
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        hidden_dim = self.config["hidden_dim"]
+
+        self.embedding_node_lin = nn.Linear(self.config["node_dim"], hidden_dim, bias=True)
+        self.embedding_edge_lin = nn.Linear(self.config["edge_dim"], hidden_dim, bias=True)
+
+        self.AttentiveFP = AttentiveFP(self.config)
+        self.Linears = SolventLayer(self.config) 
+
+
+    def forward(self, **kwargs):
+        graph = kwargs.get('compound_graphs', kwargs.get('graph'))
+        node_feats = kwargs.get('compound_node_feature', kwargs.get('node_feats'))
+        edge_feats = kwargs.get('compound_edge_feature', kwargs.get('edge_feats'))
+        solv_graph = kwargs.get('solvent_graphs', kwargs.get('solv_graph'))
+        solv_node_feats = kwargs.get('solvent_node_feature', kwargs.get('solv_node_feats'))
+        missing = [
+            name
+            for name, value in {
+                "compound_graphs": graph,
+                "compound_node_feature": node_feats,
+                "compound_edge_feature": edge_feats,
+                "solvent_graphs": solv_graph,
+                "solvent_node_feature": solv_node_feats,
+            }.items()
+            if value is None
+        ]
+        if missing:
+            raise ValueError(
+                f"SolventAFP input is missing required fields {missing!r}."
+            )
+
+        node = self.embedding_node_lin(node_feats)
+        edge = self.embedding_edge_lin(edge_feats)
+
+        super_node, att_w = self.AttentiveFP(graph, node, edge)
+
+        output = self.Linears(super_node, solv_graph, solv_node_feats)
+        return output
+
+
+network = SolventAFP

D4CMPP2/networks/DMPNN_model.py

@@ -0,0 +1,90 @@
+import torch
+import torch.nn as nn
+
+from D4CMPP2.networks.base import (
+    InputContract,
+    MolecularNetwork,
+    STANDARD_GRAPH_HYPERPARAMETERS,
+    STANDARD_GRAPH_OPTIMIZATION_SPACE,
+)
+from D4CMPP2.networks.src.Linear import Linears
+from D4CMPP2.networks.src.DMPNN import DMPNNLayer
+from D4CMPP2.networks.src.GCN import graph_sum_pool
+
+
+class DMPNN(MolecularNetwork):
+    """Directed-edge message-passing network."""
+
+    model_name = "dmpnn"
+    required_config = ("node_dim", "edge_dim", "target_dim")
+    input_contract = InputContract(
+        required=(
+            "compound_graphs",
+            "compound_node_feature",
+            "compound_edge_feature",
+        )
+    )
+    hyperparameters = STANDARD_GRAPH_HYPERPARAMETERS
+    default_optimization_space = STANDARD_GRAPH_OPTIMIZATION_SPACE
+
+    def __init__(self, config):
+        super().__init__(config)
+        hidden_dim = self.config["hidden_dim"]
+        conv_layers = self.config["conv_layers"]
+        dropout = self.config["dropout"]
+        linear_layers = self.config["linear_layers"]
+        target_dim = self.config["target_dim"]
+
+        self.embedding_node_lin = nn.Linear(self.config["node_dim"], hidden_dim, bias=True)
+        self.embedding_edge_lin = nn.Linear(self.config["edge_dim"], hidden_dim, bias=True)
+        self.init_h_func = nn.Sequential(
+            nn.Linear(2 * hidden_dim, hidden_dim, bias=True),
+            nn.LeakyReLU()
+        )
+        self.W_a = nn.Sequential(
+            nn.Linear(2 * hidden_dim, hidden_dim, bias=True),
+            nn.LeakyReLU()
+        )
+        self.dropout_layer = nn.Dropout(dropout)
+        self.DMPNNLayer = nn.ModuleList([DMPNNLayer(hidden_dim,hidden_dim,hidden_dim,nn.LeakyReLU(),dropout) for _ in range(conv_layers)])
+        self.Linears = Linears(hidden_dim, target_dim, nn.LeakyReLU(), linear_layers, dropout, last = True)
+        
+    def send_income_edge(self, edges):
+        return {'mail': edges.data['feat']}
+
+    def sum_income_edge(self, nodes):
+        hidden_feats = self.W_a(torch.cat([nodes.data['feat'], torch.sum(nodes.mailbox['mail'], 1)], dim=-1))
+        hidden_feats = self.dropout_layer(hidden_feats)
+        return {'hidden_feats': hidden_feats}
+
+    def forward(self, **kwargs):
+        graph = kwargs.get('compound_graphs', kwargs.get('graph'))
+        node_feats = kwargs.get('compound_node_feature', kwargs.get('node_feats'))
+        edge_feats = kwargs.get('compound_edge_feature', kwargs.get('edge_feats'))
+        missing = [
+            name
+            for name, value in {
+                "compound_graphs": graph,
+                "compound_node_feature": node_feats,
+                "compound_edge_feature": edge_feats,
+            }.items()
+            if value is None
+        ]
+        if missing:
+            raise ValueError(f"DMPNN input is missing required fields {missing!r}.")
+
+        node = self.embedding_node_lin(node_feats)
+        edge = self.embedding_edge_lin(edge_feats)
+
+        direct_feats = None
+        backward_feats = None
+        for layer in self.DMPNNLayer:
+            hidden_feats, direct_feats, backward_feats = layer(graph, node, edge, direct_feats, backward_feats)
+
+        graph_feats = graph_sum_pool(graph, hidden_feats)
+        output = self.Linears(graph_feats)
+        return output
+
+network = DMPNN
+
+