cleaned code

app.py

@@ -1,209 +1,38 @@
-import pandas as pd
-df = pd.read_csv('/Users/saicharan/chembl_10000.csv')
-from molgenevalmetric import SYBAscore
-
 import evaluate
-met = evaluate.load("saicharan2804/molgenevalmetric")
-
-ls= df['SMILES'].tolist()
-ls_gen = ls[0:500]
-ls_train = ls[500:1000]
-
-print('computing')
-# print(SYBAscore(gen=ls_gen))
-print(met.compute(gensmi = ls_gen, trainsmi = ls_train))
-# print(qed_metric(gen=ls_gen))
-# print(logP_metric(gen=ls_gen))
-# print(average_sascore(gen=ls_gen))
-
-# print(oracles(gen=ls_gen, train=ls_train))
+from evaluate.utils import launch_gradio_widget
+import gradio as gr
 
-# import evaluate
-# from evaluate.utils import launch_gradio_widget
-# import gradio as gr
+module = evaluate.load("saicharan2804/molgenevalmetric")
+# launch_gradio_widget(module)
 
-# module = evaluate.load("saicharan2804/molgenevalmetric")
-# # launch_gradio_widget(module)
+iface = gr.Interface(
+    fn = module.compute,
+    inputs=[
+        gr.File(label="Generated SMILES"), 
+        gr.File(label="Training Data", value=None),
+        ],
+    outputs="text"
+)
 
-# iface = gr.Interface(
-#     fn = module,
-#     inputs=[
-#         gr.File(label="Generated SMILES"), 
-#         gr.File(label="Training Data", value=None),
-#         ],
-#     outputs="text"
-# )
+iface.launch()
 
-# iface.launch()
 
 # import pandas as pd
+# from molgenevalmetric import penalized_logp
+# import evaluate
 
-# df = pd.read_csv('/home/saicharan/Downloads/chembl.csv')
-
-# df = df.rename(columns={'canonical_smiles': 'SMILES'})
-
-# df = df[0:10000]
-
-# print(df[['SMILES']].to_csv('/home/saicharan/Downloads/chembl_10000.csv'))
-# from SCScore import SCScorer
-
-
-# '''
-# This is a standalone, importable SCScorer model. It does not have tensorflow as a
-# dependency and is a more attractive option for deployment. The calculations are
-# fast enough that there is no real reason to use GPUs (via tf) instead of CPUs (via np)
-# '''
-
-# import numpy as np
-# import time
-# import rdkit.Chem as Chem
-# import rdkit.Chem.AllChem as AllChem
-# import json
-# import gzip
-# import six
-
-# import os
-# project_root = os.path.dirname(os.path.dirname(__file__))
-
-# score_scale = 5.0
-# min_separation = 0.25
-
-# FP_len = 1024
-# FP_rad = 2
-
-# def sigmoid(x):
-#   return 1 / (1 + np.exp(-x))
-
-# class SCScorer():
-#     def __init__(self, score_scale=score_scale):
-#         self.vars = []
-#         self.score_scale = score_scale
-#         self._restored = False
-
-#     def restore(self, weight_path=os.path.join('model.ckpt-10654.as_numpy.json.gz'), FP_rad=FP_rad, FP_len=FP_len):
-#         self.FP_len = FP_len; self.FP_rad = FP_rad
-#         self._load_vars(weight_path)
-#         # print('Restored variables from {}'.format(weight_path))
-
-#         if 'uint8' in weight_path or 'counts' in weight_path:
-#             def mol_to_fp(self, mol):
-#                 if mol is None:
-#                     return np.array((self.FP_len,), dtype=np.uint8)
-#                 fp = AllChem.GetMorganFingerprint(mol, self.FP_rad, useChirality=True) # uitnsparsevect
-#                 fp_folded = np.zeros((self.FP_len,), dtype=np.uint8)
-#                 for k, v in six.iteritems(fp.GetNonzeroElements()):
-#                     fp_folded[k % self.FP_len] += v
-#                 return np.array(fp_folded)
-#         else:
-#             def mol_to_fp(self, mol):
-#                 if mol is None:
-#                     return np.zeros((self.FP_len,), dtype=np.float32)
-#                 return np.array(AllChem.GetMorganFingerprintAsBitVect(mol, self.FP_rad, nBits=self.FP_len,
-#                     useChirality=True), dtype=np.bool_)
-#         self.mol_to_fp = mol_to_fp
-
-#         self._restored = True
-#         return self
-
-#     def smi_to_fp(self, smi):
-#         if not smi:
-#             return np.zeros((self.FP_len,), dtype=np.float32)
-#         return self.mol_to_fp(self, Chem.MolFromSmiles(smi))
-
-#     def apply(self, x):
-#         if not self._restored:
-#             raise ValueError('Must restore model weights!')
-#         # Each pair of vars is a weight and bias term
-#         for i in range(0, len(self.vars), 2):
-#             last_layer = (i == len(self.vars)-2)
-#             W = self.vars[i]
-#             b = self.vars[i+1]
-#             x = np.matmul(x, W) + b
-#             if not last_layer:
-#                 x = x * (x > 0) # ReLU
-#         x = 1 + (score_scale - 1) * sigmoid(x)
-#         return x
-
-#     def get_score_from_smi(self, smi='', v=False):
-#         if not smi:
-#             return ('', 0.)
-#         fp = np.array((self.smi_to_fp(smi)), dtype=np.float32)
-#         if sum(fp) == 0:
-#             if v: print('Could not get fingerprint?')
-#             cur_score = 0.
-#         else:
-#             # Run
-#             cur_score = self.apply(fp)
-#             if v: print('Score: {}'.format(cur_score))
-#         mol = Chem.MolFromSmiles(smi)
-#         if mol:
-#             smi = Chem.MolToSmiles(mol, isomericSmiles=True, kekuleSmiles=True)
-#         else:
-#             smi = ''
-#         return (smi, cur_score)
-    
-#     def get_avg_score(self, smis):
-#         """
-#         Compute the average score for a list of SMILES strings.
-
-#         Args:
-#             smis (list of str): A list of SMILES strings.
-
-#         Returns:
-#             float: The average score of the given SMILES strings.
-#         """
-#         if not smis:  # Check if the list is empty
-#             return 0.0
-        
-#         total_score = 0.0
-#         valid_smiles_count = 0
-        
-#         for smi in smis:
-#             _, score = self.get_score_from_smi(smi)
-#             if score > 0:  # Assuming only positive scores are valid
-#                 total_score += score
-#                 valid_smiles_count += 1
-
-#         # Avoid division by zero
-#         if valid_smiles_count == 0:
-#             return 0.0
-#         else:
-#             return total_score / valid_smiles_count
-
-#     def _load_vars(self, weight_path):
-#         if weight_path.endswith('pickle'):
-#             import pickle
-#             with open(weight_path, 'rb') as fid:
-#                 self.vars = pickle.load(fid)
-#                 self.vars = [x.tolist() for x in self.vars]
-#         elif weight_path.endswith('json.gz'):
-#             with gzip.GzipFile(weight_path, 'r') as fin:    # 4. gzip
-#                 json_bytes = fin.read()                      # 3. bytes (i.e. UTF-8)
-#                 json_str = json_bytes.decode('utf-8')            # 2. string (i.e. JSON)
-#                 self.vars = json.loads(json_str)
-#                 self.vars = [np.array(x) for x in self.vars]
-
-
-
-
-
-# from myscscore.SCScore import SCScorer
-# import pandas as pd
-
-# model = SCScorer()
-# model.restore()
-# # import evaluate
-# # molgenevalmetric = evaluate.load("saicharan2804/molgenevalmetric")
-
-# df = pd.read_csv('/home/saicharan/Downloads/chembl_10000.csv')
-    
+# df = pd.read_csv('/Users/saicharan/chembl_10000.csv')
 # ls= df['SMILES'].tolist()
-# ls_gen = ls[0:5000]
-# ls_train = ls[5000:10000]
+# ls_gen = ls[0:500]
+# ls_train = ls[500:1000]
 
 # print('computing')
-# average_score = model.get_avg_score(ls_gen)
+# print(penalized_logp(gen=ls_gen))
+# print(SYBAscore(gen=ls_gen))
+# print(qed_metric(gen=ls_gen))
+# print(logP_metric(gen=ls_gen))
+# print(average_sascore(gen=ls_gen))
+# print(oracles(gen=ls_gen, train=ls_train))
 
-# # Print the average score
-# print('Average score:', average_score)
-# # print(molgenevalmetric.compute(gensmi = ls_gen, trainsmi = ls_train))
+# met = evaluate.load("saicharan2804/molgenevalmetric")
+# print(met.compute(gensmi = ls_gen, trainsmi = ls_train))

molgenevalmetric.py

@@ -2,39 +2,24 @@
 import evaluate
 import datasets
 import pandas as pd
-from tdc import Evaluator
-from tdc import Oracle
-from rdkit.Chem.QED import qed
-from rdkit.Chem.Crippen import MolLogP
-import os
-from collections import Counter
-from functools import partial
 import numpy as np
-import pandas as pd
 import scipy.sparse
 import torch
+import warnings
+from multiprocessing import Pool
+from functools import partial
+from fcd_torch import FCD
+
+from tdc import Oracle
+from rdkit.Chem.Crippen import MolLogP
 from rdkit import Chem
-from rdkit.Chem import AllChem
 from rdkit.Chem import MACCSkeys
 from rdkit.Chem.AllChem import GetMorganFingerprintAsBitVect as Morgan
 from rdkit.Chem.QED import qed
-from rdkit.Chem.Scaffolds import MurckoScaffold
-from rdkit.Chem import Descriptors
-from multiprocessing import Pool
-from collections import UserList, defaultdict
-import numpy as np
-import pandas as pd
-from rdkit import rdBase
 from rdkit.Contrib.SA_Score import sascorer
-import sys
-from rdkit.Chem import RDConfig
-import os
-import pandas as pd
-from fcd_torch import FCD
-from syba.syba import SybaClassifier
 
+from syba.syba import SybaClassifier
 from myscscore.SCScore import SCScorer
-import warnings
 
 
 def get_mol(smiles_or_mol):
@@ -196,7 +181,7 @@ def calculate_sa_score(smiles):
     Returns:
     - float: SA score of the molecule, or None if the molecule couldn't be created.
     """
-    mol = Chem.MolFromSmiles(smiles)
+    mol = get_mol(smiles)
     if mol:
         return sascorer.calculateScore(mol)
     else:
@@ -431,7 +416,7 @@ def qed_metric(gen):
     qed_scores = []
     for smiles in gen:
         try:
-            mol = Chem.MolFromSmiles(smiles)
+            mol = get_mol(smiles)
             if mol:  # Ensure molecule is valid
                 qed_scores.append(qed(mol))
         except Exception as e:
@@ -461,7 +446,7 @@ def logP_metric(gen):
     logP_values = []
     for smiles in gen:
         try:
-            mol = Chem.MolFromSmiles(smiles)
+            mol = get_mol(smiles)
             if mol:  # Ensure molecule is valid
                 logP_values.append(MolLogP(mol))
         except Exception as e:
@@ -473,45 +458,24 @@ def logP_metric(gen):
     else:
         return 0.0  # Return 0 or suitable value if no valid molecules are processed
 
-
-def oracles(gen, train):
-
+def penalized_logp(gen):
     """
-    Computes scores from various oracles for a list of generated molecules.
+    Computes the average PyTDC's penalized logP value for a list of SMILES strings.
 
     Parameters:
-    - gen (List[str]): List of generated SMILES strings.
-    - train (List[str]): List of training set SMILES strings.
+    - mols (List[str]): List of SMILES strings representing the molecules.
 
     Returns:
-    - Dict[str, Any]: A dictionary with oracle names as keys and their corresponding scores as values.
-    """
-
-    result = {}
-
-    # oracle_list = [
-    # 'QED', '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)
-            if isinstance(score, dict):
-                score = {key: sum(values)/len(values) for key, values in score.items()}
-        else:
-            score = oracle(gen)
-            if isinstance(score, list):
-                score = sum(score) / len(score)
+    - float: Average penalized logP value for the list of molecules.
+    """
+    oracle = Oracle('LogP')
+
+    score = oracle(gen)
+    if isinstance(score, list):
+        score = sum(score) / len(score)
         
-        result[f"{oracle_name}"] = score
-    
-    return result
+    return score
+
 
 
 
@@ -533,33 +497,7 @@ Returns:
 
 
 _CITATION = """
-@article{DBLP:journals/corr/abs-1811-12823,
-  author       = {Daniil Polykovskiy and
-                  Alexander Zhebrak and
-                  Benjam{\'{\i}}n S{\'{a}}nchez{-}Lengeling and
-                  Sergey Golovanov and
-                  Oktai Tatanov and
-                  Stanislav Belyaev and
-                  Rauf Kurbanov and
-                  Aleksey Artamonov and
-                  Vladimir Aladinskiy and
-                  Mark Veselov and
-                  Artur Kadurin and
-                  Sergey I. Nikolenko and
-                  Al{\'{a}}n Aspuru{-}Guzik and
-                  Alex Zhavoronkov},
-  title        = {Molecular Sets {(MOSES):} {A} Benchmarking Platform for Molecular
-                  Generation Models},
-  journal      = {CoRR},
-  volume       = {abs/1811.12823},
-  year         = {2018},
-  url          = {http://arxiv.org/abs/1811.12823},
-  eprinttype    = {arXiv},
-  eprint       = {1811.12823},
-  timestamp    = {Fri, 26 Nov 2021 15:34:30 +0100},
-  biburl       = {https://dblp.org/rec/journals/corr/abs-1811-12823.bib},
-  bibsource    = {dblp computer science bibliography, https://dblp.org}
-}
+
 """
 
 
@@ -582,7 +520,7 @@ class molgenevalmetric(evaluate.Metric):
                 }
             ),
                 
-            reference_urls=["https://github.com/molecularsets/moses", "https://tdcommons.ai/functions/oracles/"],
+            reference_urls=["https://github.com/molecularsets/moses", "https://tdcommons.ai/functions/oracles/", "https://github.com/lich-uct/syba", "https://github.com/connorcoley/scscore"],
         )
 
     def _compute(self, gensmi, trainsmi):
@@ -595,46 +533,11 @@ class molgenevalmetric(evaluate.Metric):
         metrics['FCD'] = fcd_metric(gen = gensmi, train = trainsmi)
         metrics['QED'] = qed_metric(gen=gensmi)
         metrics['LogP'] = logP_metric(gen=gensmi)
+        metrics['Penalized LogP'] = penalized_logp(gen=gensmi)
         metrics['SA'] = average_sascore(gen=gensmi)
-        metrics['SCS'] = synthetic_complexity_score(gen=gensmi)
+        metrics['SCScore'] = synthetic_complexity_score(gen=gensmi)
         metrics['SYBA'] = SYBAscore(gen=gensmi)
-        metrics['Oracles'] = oracles(gen = gensmi, train = trainsmi)
+        # metrics['Oracles'] = oracles(gen = gensmi, train = trainsmi)
 
         return metrics
 
-        
-        # generated_smiles = [s for s in generated_smiles if s != '']
-
-        # evaluator = Evaluator(name = 'KL_Divergence')
-        # KL_Divergence = evaluator(generated_smiles, train_smiles)
-                
-        # Results.update({
-        #     "KL_Divergence": KL_Divergence,
-        # })
-
-
-        # oracle_list = [
-        # 'QED', 'SA', 'MPO', 'GSK3B', 'JNK3',
-        # 'DRD2', 'LogP', 'Rediscovery', 'Similarity',
-        # 'Median', 'Isomers', 'Valsartan_SMARTS', 'Hop'
-        # ]
-    
-        # for oracle_name in oracle_list:
-        #     oracle = Oracle(name=oracle_name)
-        #     if oracle_name in ['Rediscovery', 'MPO', 'Similarity', 'Median', 'Isomers', 'Hop']:
-        #         score = oracle(generated_smiles)
-        #         if isinstance(score, dict):
-        #             score = {key: sum(values)/len(values) for key, values in score.items()}
-        #     else:
-        #         score = oracle(generated_smiles)
-        #         if isinstance(score, list):
-        #             score = sum(score) / len(score)
-            
-        #     Results.update({f"{oracle_name}": score})
-
-        # # keys_to_remove = ["FCD/TestSF", "SNN/TestSF", "Frag/TestSF", "Scaf/TestSF"]
-        # # for key in keys_to_remove:
-        # #     Results.pop(key, None)    
-
-        # return {"results": Results}
-