Download app.py from ligdis/4: direct link, hf CLI and curl.
- Browser
- Download file 15.5 kB
-
https://huggingface.co/spaces/ligdis/4/resolve/main/app.py
- Command line
-
hf download hf://spaces/ligdis/4/app.py
-
curl -L -o app.py https://huggingface.co/spaces/ligdis/4/resolve/main/app.py
15.5 kB
| import streamlit as st | |
| import sys | |
| from fragment_embedder import FragmentEmbedder | |
| from morgan_desc import * | |
| from physchem_desc import * | |
| from rdkit import Chem | |
| import pandas as pd | |
| import os | |
| import random | |
| import numpy as np | |
| import joblib | |
| from rdkit import Chem | |
| from rdkit.Chem import Draw | |
| from rdkit.Chem import Draw | |
| from rdkit.Chem import AllChem | |
| from rdkit import DataStructs | |
| from rdkit.Chem import Descriptors | |
| from scipy import stats | |
| import textwrap | |
| from datasets import load_dataset | |
| import requests | |
| from io import BytesIO | |
| import urllib.request | |
| # import miniautoml | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| st.set_page_config( | |
| page_title="Ligand Discovery 4: Fragment Predictions", | |
| page_icon=":home:", | |
| layout="wide", # "centered", | |
| initial_sidebar_state="expanded" | |
| ) | |
| st.markdown(""" | |
| <style> | |
| .css-13sdm1b.e16nr0p33 { | |
| margin-top: -75px; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| hide_streamlit_style = """ | |
| <style> | |
| #MainMenu {visibility: hidden;} | |
| footer {visibility: hidden;} | |
| #header {visibility: hidden;} | |
| </style> | |
| """ | |
| st.markdown(hide_streamlit_style, unsafe_allow_html=True) | |
| dataset = load_dataset('ligdis/data', data_files={"predictions.csv"}) | |
| df_predictions = dataset['train'].to_pandas() | |
| predictions_inchikeys = df_predictions["inchikey"].tolist() | |
| df_predictions = df_predictions.rename(columns={"inchikey": "InChIKey"}) | |
| dataset = load_dataset('ligdis/data', data_files={"applicability.csv"}) | |
| df_applicability = dataset['train'].to_pandas() | |
| df_predictions = pd.concat([df_predictions, df_applicability], axis=1) | |
| dataset = load_dataset('ligdis/data', data_files={"cemm_smiles.csv"}) | |
| cemm_smiles = dataset['train'].to_pandas() | |
| fid2smi = {} | |
| for r in cemm_smiles.values: | |
| fid2smi[r[0]] = r[1] | |
| fe = FragmentEmbedder() | |
| CRF_PATTERN = "CC1(CCC#C)N=N1" | |
| CRF_PATTERN_0 = "C#CC" | |
| CRF_PATTERN_1 = "N=N" | |
| dataset = load_dataset('ligdis/data', data_files={"all_fff_enamine.csv"}) | |
| enamine_catalog = dataset['train'].to_pandas() | |
| enamine_catalog_ids_set = set(enamine_catalog["catalog_id"]) | |
| enamine_catalog_dict = {} | |
| catalog2inchikey = {} | |
| smiles2catalog = {} | |
| for i, r in enumerate(enamine_catalog.values): | |
| enamine_catalog_dict[r[0]] = r[1] | |
| catalog2inchikey[r[0]] = predictions_inchikeys[i] | |
| smiles2catalog[r[1]] = r[0] | |
| def is_enamine_catalog_id(identifier): | |
| if identifier in enamine_catalog_ids_set: | |
| return True | |
| else: | |
| return False | |
| def is_enamine_smiles(identifier): | |
| if identifier in smiles2catalog: | |
| return True | |
| else: | |
| return False | |
| def is_ligand_discovery_id(identifier): | |
| if identifier in fid2smi: | |
| return True | |
| else: | |
| return False | |
| def is_valid_smiles(smiles): | |
| try: | |
| mol = Chem.MolFromSmiles(smiles) | |
| except: | |
| mol = None | |
| if mol is None: | |
| return False | |
| else: | |
| return True | |
| def has_crf(mol): | |
| pattern = CRF_PATTERN | |
| has_pattern = mol.HasSubstructMatch(Chem.MolFromSmarts(pattern)) | |
| if not has_pattern: | |
| if mol.HasSubstructMatch( | |
| Chem.MolFromSmarts(CRF_PATTERN_0) | |
| ) and mol.HasSubstructMatch(Chem.MolFromSmarts(CRF_PATTERN_1)): | |
| return True | |
| else: | |
| return False | |
| return True | |
| dataset = load_dataset('ligdis/data', data_files={"model_catalog.csv"}) | |
| dm = dataset['train'].to_pandas() | |
| all_models = dm["model_name"].tolist() | |
| dataset = load_dataset('ligdis/data', data_files={"models_performance.tsv"}) | |
| dp = dataset['train'].to_pandas() | |
| model_display = {} | |
| model_description = {} | |
| for r in dm.values: | |
| model_display[r[0]] = r[1] | |
| model_description[r[0]] = r[2] | |
| model_auroc = {} | |
| for r in dp.values: | |
| model_auroc[r[0]] = r[1] | |
| prom_models = [x for x in dm["model_name"].tolist() if x.startswith("promiscuity")] | |
| sign_models = [x for x in dm["model_name"].tolist() if x.startswith("signature")] | |
| global_promiscuity_models = ["promiscuity_pxf0", "promiscuity_pxf1", "promiscuity_pxf2"] | |
| specific_promiscuity_models = ["promiscuity_fxp0_pxf0", "promiscuity_fxp1_pxf0","promiscuity_fxp2_pxf0", "promiscuity_fxp0_pxf1", "promiscuity_fxp1_pxf1", "promiscuity_fxp2_pxf1", "promiscuity_fxp0_pxf2", "promiscuity_fxp1_pxf2", "promiscuity_fxp2_pxf2"] | |
| def model_to_markdown(model_names): | |
| items = [] | |
| for mn in model_names: | |
| items += [ | |
| "{0} ({1:.3f}): {2}".format( | |
| model_display[mn].ljust(8), model_auroc[mn], model_description[mn] | |
| ) | |
| ] | |
| markdown_list = "\n".join(items) | |
| return markdown_list | |
| st.sidebar.title("Ligand Discovery 4: Fragment Predictions") | |
| placeholder_text = [] | |
| keys = random.sample(sorted(enamine_catalog_ids_set), 5) | |
| for k in keys: | |
| placeholder_text += [random.choice([k, enamine_catalog_dict[k]])] | |
| placeholder_text = "\n".join(placeholder_text) | |
| text_input = st.sidebar.text_area(label="Input your fully functionalized fragments:") | |
| inputs = [x.strip(" ") for x in text_input.split("\n")] | |
| inputs = [x for x in inputs if x != ""] | |
| if len(inputs) > 999: | |
| st.sidebar.error("Please limit the number of input fragments to 999.") | |
| st.sidebar.info("This tool expects fully functionalized fragments (FFF) as input, including the diazirine+alkyne probe (CRF). We have tailored the chemical space of the predictions to FFFs; the app will through an error if any of the input molecules does not contain a CRF region. Enamine provides a good [catalog](https://enamine.net/compound-libraries/fragment-libraries/fully-functionalized-probe-library) of FFFs. For a quick test input, use any of the options below") | |
| example_0 = ["Z5645472552", "Z5645472643", "Z5645472785"] | |
| st.sidebar.markdown("**Input Enamine FFF identifiers...**") | |
| st.sidebar.text("\n".join(example_0)) | |
| example_1 = ["C#CCCC1(CCCNC(=O)C(Cc2c[nH]c3ncccc23)NC(=O)OC(C)(C)C)N=N1", "C#CCCC1(CCCNC(=O)[C@H]2CCC(=O)NC2)N=N1", "C#CCCC1(CCCNC(=O)CSc2ncc(C(=O)OCC)c(N)n2)N=N1"] | |
| st.sidebar.markdown("**Input FFF SMILES strings...**") | |
| st.sidebar.text("\n".join(example_1)) | |
| example_2 = ["C310", "C045", "C391"] | |
| st.sidebar.markdown("**Input Ligand Discovery identifiers...**") | |
| st.sidebar.text("\n".join(example_2)) | |
| example_3 = ["Z5645486561", "C#CCCCC1(CCCC(=O)N2CCC(C(C(=O)O)c3ccc(C)cc3)CC2)N=N1", "C279"] | |
| st.sidebar.markdown("**Input a mix of the above identifiers**") | |
| st.sidebar.text("\n".join(example_3)) | |
| R = [] | |
| all_inputs_are_valid = True | |
| for i, inp in enumerate(inputs): | |
| input_id = "input-{0}".format(str(i).zfill(3)) | |
| if is_enamine_catalog_id(inp): | |
| smiles = enamine_catalog_dict[inp] | |
| inchikey = catalog2inchikey[inp] | |
| r = [inp, smiles, inchikey] | |
| elif is_ligand_discovery_id(inp): | |
| smiles = fid2smi[inp] | |
| inchikey = Chem.MolToInchiKey(Chem.MolFromSmiles(smiles)) | |
| r = [inp, smiles, inchikey] | |
| elif is_enamine_smiles(inp): | |
| smiles = inp | |
| inp = smiles2catalog[smiles] | |
| inchikey = catalog2inchikey[inp] | |
| r = [inp, smiles, inchikey] | |
| elif is_valid_smiles(inp): | |
| mol = Chem.MolFromSmiles(inp) | |
| if has_crf(mol): | |
| inchikey = Chem.rdinchi.InchiToInchiKey(Chem.MolToInchi(mol)) | |
| r = [inchikey, inp, inchikey] | |
| else: | |
| st.error( | |
| "Input SMILES {0} does not have the CRF. The CRF pattern is {1}.".format( | |
| inp, CRF_PATTERN | |
| ) | |
| ) | |
| all_inputs_are_valid = False | |
| else: | |
| st.error( | |
| "Input {0} is not valid. Please enter a valid fully-functionalized fragment SMILES string or an Enamine catalog identifier of a fully-functionalized fragment".format( | |
| inp | |
| ) | |
| ) | |
| all_inputs_are_valid = False | |
| R += [r] | |
| def get_fragment_image(smiles): | |
| m = Chem.MolFromSmiles(smiles) | |
| AllChem.Compute2DCoords(m) | |
| im = Draw.MolToImage(m, size=(200, 200)) | |
| return im | |
| st.markdown( | |
| """ | |
| Explanation for Output: The results are displayed in 4 Columns. | |
| 1. **Structure** of the FFF, InChi, Enamine ID | |
| 2. **Chemical space**: Displays the Molecular Weight (*MW*), Walden-Crippen *LogP* and Tanimoto Similarity to the most similar fragment (*Sim-1*) and third most similar fragment (*Sim-3*) in the training set | |
| 3. **Promiscuity Predictions** based on 12 Model: 3 Global (section **A**) and 9 Specific (section **B**) | |
| 4. **Ontology Predictions** based on 9 _Signature_ Models derived from protein annotations of multiple scopes - from domains and families to molecular functions and cellular localization | |
| """ | |
| ) | |
| myCol = st.columns(3) | |
| with myCol[0]: | |
| st.subheader("Promiscuity Predictions") | |
| st.markdown("**A. Global models**") | |
| st.text(model_to_markdown(global_promiscuity_models)) | |
| st.markdown("**C. Aggregated score**") | |
| st.text("Sum : Sum of individual promiscuity predictors") | |
| with myCol[1]: | |
| st.text("") | |
| st.text("") | |
| st.markdown("**B. Specific models**") | |
| st.text(model_to_markdown(specific_promiscuity_models)) | |
| with myCol[2]: | |
| st.subheader("Ontology Predictions") | |
| signature_models = ["signature_{0}".format(i) for i in range(10)] | |
| st.text(model_to_markdown(signature_models)) | |
| st.markdown( | |
| """ | |
| - Model score (range 0 -> 1) corresponds to the mean AUROC in 10 train-test splits | |
| - Percentages in parenthesis denote the percentile of the score across the Enamine collection of FFFs (>250k compounds). for example, in "Sign-4: 0.02 (35.7%)", **35.7** is the percentile of score. | |
| - The exclamation sign (!) next to the prediction output indicates that the corresponding model has an AUROC accuracy below 0.7 (*! is a warning sign*) | |
| """ | |
| ) | |
| st.divider() | |
| if all_inputs_are_valid and len(R) > 0: | |
| sum_of_promiscuities = np.sum( | |
| df_predictions[global_promiscuity_models + specific_promiscuity_models], axis=1 | |
| ) | |
| df = pd.DataFrame(R, columns=["Identifier", "SMILES", "InChIKey"]) | |
| my_inchikeys = df["InChIKey"].tolist() | |
| df_done = df[df["InChIKey"].isin(predictions_inchikeys)] | |
| df_todo = df[~df["InChIKey"].isin(predictions_inchikeys)] | |
| if df_done.shape[0] > 0: | |
| df_done = df_done.merge( | |
| df_predictions, on="InChIKey", how="left" | |
| ).drop_duplicates() | |
| if df_todo.shape[0] > 0: | |
| X = fe.transform(df_todo["SMILES"].tolist()) | |
| st.info("Making predictions... this make take a few seconds. Please be patient. We may experience high traffic. If something goes wrong, please try again later.") | |
| progress_bar = st.progress(0) | |
| for i, model_name in enumerate(all_models): | |
| url = ''.join(('https://huggingface.co/ligdis/fpred/resolve/main/', model_name, '.joblib')) # The URL of the file you want to load | |
| with urllib.request.urlopen(url) as response: # Download the file | |
| model = joblib.load(BytesIO(response.read())) | |
| vals = model.predict(X) | |
| del model | |
| progress_bar.progress((i + 1) / len(all_models)) | |
| df_todo[model_name] = vals | |
| url = 'https://huggingface.co/ligdis/fpred/resolve/main/cemm_ecfp_2_1024.joblib' # The URL of the file you want to load | |
| with urllib.request.urlopen(url) as response: # Download the file | |
| dataset_fps = joblib.load(BytesIO(response.read())) | |
| all_query_smiles = df_todo["SMILES"].tolist() | |
| sims_1 = [] | |
| sims_3 = [] | |
| logps = [] | |
| mwts = [] | |
| for query_smiles in all_query_smiles: | |
| query_mol = Chem.MolFromSmiles(query_smiles) | |
| query_fp = AllChem.GetMorganFingerprintAsBitVect(query_mol, 2, nBits=1024) | |
| similarity_scores = [ | |
| DataStructs.TanimotoSimilarity(query_fp, dataset_fp) | |
| for dataset_fp in dataset_fps | |
| ] | |
| sorted_scores_indices = sorted( | |
| enumerate(similarity_scores), key=lambda x: x[1], reverse=True | |
| ) | |
| top_n = 3 | |
| sims_1 += [sorted_scores_indices[0][1]] | |
| sims_3 += [sorted_scores_indices[2][1]] | |
| logps += [Descriptors.MolLogP(query_mol)] | |
| mwts += [Descriptors.MolWt(query_mol)] | |
| results = {"sims-1": sims_1, "sims-3": sims_3, "logp": logps, "mw": mwts} | |
| for k in ["sims-1", "sims-3", "logp", "mw"]: | |
| df_todo[k] = results[k] | |
| if df_done.shape[0] > 0 and df_todo.shape[0] > 0: | |
| df_ = pd.concat([df_done, df_todo]) | |
| else: | |
| if df_done.shape[0] > 0: | |
| df_ = df_done | |
| else: | |
| df_ = df_todo | |
| df_ = df_.drop(columns=["Identifier", "SMILES"]) | |
| df = df.merge(df_, on="InChIKey", how="left") | |
| df.drop_duplicates(subset=['InChIKey'], keep='first', inplace=True, ignore_index=True) | |
| df = df.rename(columns=model_display) | |
| applicability_display = { | |
| "mw": "MW", | |
| "logp": "LogP", | |
| "sims-1": "Sim-1", | |
| "sims-3": "Sim-3", | |
| } | |
| df = df.rename(columns=applicability_display) | |
| df_predictions = df_predictions.rename(columns=model_display) | |
| df_predictions = df_predictions.rename(columns=applicability_display) | |
| prom_columns = [] | |
| for i in range(3): | |
| prom_columns += ["Prom-{0}".format(i)] | |
| for j in range(3): | |
| prom_columns += ["Prom-{0}-{0}".format(i, j)] | |
| def identifiers_text(ik, smi, ident): | |
| s = ["{0}".format(ik), "{0}".format(smi)] | |
| if ik != ident: | |
| s += ["{0}".format(ident)] | |
| return "\n".join(s) | |
| def score_text(v, c): | |
| all_scores = np.array(df_predictions[c]) | |
| perc = stats.percentileofscore(all_scores, v) | |
| t = "{0}: {1:.2f} ({2:.1f}%)".format(c.ljust(8), v, perc).ljust(22) | |
| if c == "Sign-4" or c == "Sign-7" or c == "Sign-3": | |
| t += " (!)" | |
| return t | |
| def score_texts(vs, cs): | |
| all_texts = [] | |
| for v, c in zip(vs, cs): | |
| all_texts += [score_text(v, c)] | |
| return "\n".join(all_texts) | |
| dorig = pd.DataFrame({"InChIKey": my_inchikeys}) | |
| df = dorig.merge(df, on="InChIKey", how="left") | |
| df = df.reset_index(inplace=False, drop=True) | |
| for i, r in enumerate(df.iterrows()): | |
| v = r[1] | |
| st.markdown("#### Input {0}: `{1}`".format(i+1, inputs[r[0]])) | |
| cols = st.columns(4) | |
| cols[0].markdown("**Fragment**") | |
| cols[0].image(get_fragment_image(v["SMILES"])) | |
| cols[0].text(identifiers_text(v["InChIKey"], v["SMILES"], v["Identifier"])) | |
| cols[1].markdown("**Chemical space**") | |
| my_cols = ["MW", "LogP", "Sim-1", "Sim-3"] | |
| cols[1].text(score_texts(v[my_cols], my_cols)) | |
| cols[2].markdown("**Promiscuity**") | |
| sum_prom = np.sum(v[prom_columns]) | |
| perc_prom = stats.percentileofscore(sum_of_promiscuities, sum_prom) | |
| my_cols = ["Prom-0", "Prom-1", "Prom-2"] | |
| cols[2].text(score_texts(v[my_cols], my_cols)) | |
| my_cols = [ | |
| "Prom-0-0", | |
| "Prom-0-1", | |
| "Prom-0-2", | |
| "Prom-1-0", | |
| "Prom-1-1", | |
| "Prom-1-2", | |
| "Prom-2-0", | |
| "Prom-2-1", | |
| "Prom-2-2", | |
| ] | |
| cols[2].text(score_texts(v[my_cols], my_cols)) | |
| cols[2].text("Sum : {0:.2f} ({1:.1f}%)".format(sum_prom, perc_prom)) | |
| cols[3].markdown("**Signatures**") | |
| my_cols = ["Sign-{0}".format(i) for i in range(10)] | |
| cols[3].text(score_texts(v[my_cols], my_cols)) | |
| st.divider() | |
| def convert_df(df): | |
| return df.to_csv(index=False).encode("utf-8") | |
| csv = convert_df(df) | |
| st.download_button( | |
| "Download as CSV", csv, "predictions.csv", "text/csv", key="download-csv" | |
| ) | |