Many additions

molgenevalmetric.py

@@ -4,10 +4,11 @@ import datasets
 # import moses
 # from moses import metrics
 import pandas as pd
-# from tdc import Evaluator
-# from tdc import Oracle
+from tdc import Evaluator
+from tdc import Oracle
 # from metrics import novelty, fraction_valid, fraction_unique, SAscore, internal_diversity,fcd_metric, SYBAscore, oracles
-
+from rdkit.Chem.QED import qed
+from rdkit.Chem.Crippen import MolLogP
 import os
 from collections import Counter
 from functools import partial
@@ -41,6 +42,8 @@ from fcd_torch import FCD
 # from SCScore import SCScorer
 
 from myscscore.SCScore import SCScorer
+import warnings
+
 
 def get_mol(smiles_or_mol):
     """
@@ -174,29 +177,6 @@ def novelty(gen, train, n_jobs=1):
     return len(gen_smiles_set - train_set) / len(gen_smiles_set)
 
 
-# def SAscore(gen):
-#     """
-#     Calculate the average Synthetic Accessibility Score (SAscore) for a list of molecules represented by their SMILES strings.
-
-#     Parameters:
-#     - smiles_list (list of str): A list containing the SMILES representations of the molecules.
-
-#     Returns:
-#     - float: The average Synthetic Accessibility Score for the valid molecules in the list. Returns None if no valid molecules are found.
-#     """
-#     scores = []
-#     for smiles in gen:
-#         mol = Chem.MolFromSmiles(smiles)
-#         if mol:  # Ensures the molecule could be parsed from the SMILES string
-#             score = sascorer.calculateScore(mol)
-#             scores.append(score)
-    
-#     if scores:  # Checks if there are any scores calculated
-#         return np.mean(scores)
-#     else:
-#         return None
-
-
 def synthetic_complexity_score(gen):
     """
     Calculate the average Synthetic Complexity Score (SCScore) for a list of molecules represented by their SMILES strings.
@@ -448,6 +428,60 @@ def fcd_metric(gen, train, n_jobs = 1, device = None):
 #     else:
 #         return None  # Or handle empty list or all failed predictions as needed
 
+def qed_metric(gen):
+    """
+    Computes RDKit's QED score
+    """
+    if not gen:
+        return 0.0  # Return 0 or suitable value for empty list
+
+    # Convert SMILES strings to RDKit molecule objects and calculate QED scores
+    qed_scores = []
+    for smiles in gen:
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            if mol:  # Ensure molecule is valid
+                qed_scores.append(qed(mol))
+        except Exception as e:
+            print(f"Error processing molecule {smiles}: {str(e)}")
+
+    # Calculate the average QED score
+    if qed_scores:
+        return sum(qed_scores) / len(qed_scores)
+    else:
+        return 0.0  # Return 0 or suitable value if no valid molecules are processed
+
+def logP_metric(gen):
+    """
+    Computes the average RDKit's logP value for a list of SMILES strings.
+
+    Parameters:
+    - mols (List[str]): List of SMILES strings representing the molecules.
+
+    Returns:
+    - float: Average logP value for the list of molecules.
+    """
+    # Check if the input list is empty
+    if not gen:
+        return 0.0  # Return 0 or suitable value for empty list
+
+    # Convert SMILES strings to RDKit molecule objects and calculate logP values
+    logP_values = []
+    for smiles in gen:
+        try:
+            mol = Chem.MolFromSmiles(smiles)
+            if mol:  # Ensure molecule is valid
+                logP_values.append(MolLogP(mol))
+        except Exception as e:
+            print(f"Error processing molecule {smiles}: {str(e)}")
+
+    # Calculate the average logP value
+    if logP_values:
+        return sum(logP_values) / len(logP_values)
+    else:
+        return 0.0  # Return 0 or suitable value if no valid molecules are processed
+
+
 def oracles(gen, train):
 
     """
@@ -461,20 +495,18 @@ def oracles(gen, train):
     - Dict[str, Any]: A dictionary with oracle names as keys and their corresponding scores as values.
     """
 
-    Result = {}
-    evaluator = Evaluator(name = 'KL_Divergence')
-    KL_Divergence = evaluator(gen, train)
-            
-    Result["KL_Divergence"] = KL_Divergence
+    result = {}
 
+    # oracle_list = [
+    # 'QED', 'MPO', 'GSK3B', 'JNK3',
+    # 'DRD2', 'LogP', 'Rediscovery', 'Similarity',
+    # 'Median', 'Isomers', 'Valsartan_SMARTS', 'Hop'
+    # ]
 
-    oracle_list = [
-    'QED', 'SA', 'MPO', 'GSK3B', 'JNK3',
-    'DRD2', 'LogP', 'Rediscovery', 'Similarity',
-    'Median', 'Isomers', 'Valsartan_SMARTS', 'Hop'
-    ]
+    oracle_list = ['QED', 'LogP', 'SA']
 
     for oracle_name in oracle_list:
+        print(oracle_name)
         oracle = Oracle(name=oracle_name)
         if oracle_name in ['Rediscovery', 'MPO', 'Similarity', 'Median', 'Isomers', 'Hop']:
             score = oracle(gen)
@@ -485,9 +517,9 @@ def oracles(gen, train):
             if isinstance(score, list):
                 score = sum(score) / len(score)
         
-        Result[f"{oracle_name}"] = score
+        result[f"{oracle_name}"] = score
     
-    return Result
+    return result
 
 
 
@@ -564,12 +596,14 @@ class molgenevalmetric(evaluate.Metric):
     def _compute(self, gensmi, trainsmi):
 
         metrics = {}
-        metrics['novelty'] = novelty(gen = gensmi, train = trainsmi)
-        metrics['valid'] = fraction_valid(gen=gensmi)
-        metrics['unique'] = fraction_unique(gen=gensmi)
+        metrics['Novelty'] = novelty(gen = gensmi, train = trainsmi)
+        metrics['Valid'] = fraction_valid(gen=gensmi)
+        metrics['Unique'] = fraction_unique(gen=gensmi)
         metrics['IntDiv'] = internal_diversity(gen=gensmi)
         metrics['FCD'] = fcd_metric(gen = gensmi, train = trainsmi)
-        # metrics['Oracles'] = oracles(gen = gensmi, train = trainsmi)
+        metrics['Oracles'] = oracles(gen = gensmi, train = trainsmi)
+        metrics['QED'] = qed_metric(gen=gensmi)
+        metrics['LogP'] = logP_metric(gen=gensmi)
 
         # print('computing')