app.py

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))

# import evaluate
# from evaluate.utils import launch_gradio_widget
# import gradio as gr

# module = evaluate.load("saicharan2804/molgenevalmetric")
# # launch_gradio_widget(module)

# iface = gr.Interface(
#     fn = module,
#     inputs=[
#         gr.File(label="Generated SMILES"), 
#         gr.File(label="Training Data", value=None),
#         ],
#     outputs="text"
# )

# iface.launch()

# import pandas as pd

# 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')
    
# ls= df['SMILES'].tolist()
# ls_gen = ls[0:5000]
# ls_train = ls[5000:10000]

# print('computing')
# average_score = model.get_avg_score(ls_gen)

# # Print the average score
# print('Average score:', average_score)
# # print(molgenevalmetric.compute(gensmi = ls_gen, trainsmi = ls_train))