Upload 4 files

Filtering and new features added version.

About.py

@@ -0,0 +1,84 @@
+# Copyright 2018-2022 Streamlit Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import streamlit as st
+from streamlit.logger import get_logger
+LOGGER = get_logger(__name__)
+
+
+def run():
+    st.set_page_config(
+        page_title="About WarmMolGen",
+        page_icon="🚀",
+        layout='wide'
+    )
+
+    st.write("## [Exploiting Pretrained Biochemical Language Models for Targeted Drug Design](https://arxiv.org/abs/2209.00981)")
+    #st.sidebar.title("Model Demos")
+    st.sidebar.success("Select a model demo above.")
+
+    st.markdown(
+        """
+        This application demonstrates the generation capabilities of the models trained as part of the study below, which has been published in *Bioinformatics* Published by Oxford University Press. The available models are: 
+        * WarmMolGen
+            - WarmMolGenOne (i.e. EncDecBase)
+            - WarmMolGenTwo (i.e. EncDecLM)
+        * ChemBERTaLM 
+        👈 Select a model demo from the sidebar to generate molecules right away 🚀
+        ### Abstract
+        **Motivation:** The development of novel compounds targeting proteins of interest is one of the most important tasks in
+        the pharmaceutical industry. Deep generative models have been applied to targeted molecular design and have shown
+        promising results. Recently, target-specific molecule generation has been viewed as a translation between the protein
+        language and the chemical language. However, such a model is limited by the availability of interacting protein–ligand
+        pairs. On the other hand, large amounts of unlabelled protein sequences and chemical compounds are available and
+        have been used to train language models that learn useful representations. In this study, we propose exploiting pretrained
+        biochemical language models to initialize (i.e. warm start) targeted molecule generation models. We investigate
+        two warm start strategies: (i) a one-stage strategy where the initialized model is trained on targeted molecule generation
+        and (ii) a two-stage strategy containing a pre-finetuning on molecular generation followed by target-specific training. We
+        also compare two decoding strategies to generate compounds: beam search and sampling.
+        **Results:** The results show that the warm-started models perform better than a baseline model trained from scratch.
+        The two proposed warm-start strategies achieve similar results to each other with respect to widely used metrics
+        from benchmarks. However, docking evaluation of the generated compounds for a number of novel proteins suggests
+        that the one-stage strategy generalizes better than the two-stage strategy. Additionally, we observe that
+        beam search outperforms sampling in both docking evaluation and benchmark metrics for assessing compound
+        quality.
+        **Availability and implementation:** The source code is available at https://github.com/boun-tabi/biochemical-lms-for-drug-design and the materials (i.e., data, models, and outputs) are archived in Zenodo at https://doi.org/10.5281/zenodo.6832145. 
+        ### Citation
+        ```bibtex
+        @article{10.1093/bioinformatics/btac482,
+            author = {Uludoğan, Gökçe and Ozkirimli, Elif and Ulgen, Kutlu O and Karalı, Nilgün and Özgür, Arzucan},
+            title = "{Exploiting pretrained biochemical language models for targeted drug design}",
+            journal = {Bioinformatics},
+            volume = {38},
+            number = {Supplement_2},
+            pages = {ii155-ii161},
+            year = {2022},
+            doi = {10.1093/bioinformatics/btac482},
+            url = {https://doi.org/10.1093/bioinformatics/btac482},
+        }
+        ```
+    """
+    )
+    # page_names_to_funcs = {
+    #     "—": intro,
+    #     "Plotting Demo": plotting_demo,
+    #     "Mapping Demo": mapping_demo,
+    #     "DataFrame Demo": data_frame_demo
+    # }
+
+    # demo_name = st.sidebar.selectbox("Choose a demo", page_names_to_funcs.keys())
+    # page_names_to_funcs[demo_name]()
+
+if __name__ == "__main__":
+    run()

pages/1_🔥_WarmMolGen.py

@@ -0,0 +1,193 @@
+import streamlit as st
+import streamlit.components.v1 as components
+import pandas as pd
+import mols2grid
+from ipywidgets import interact, widgets
+import textwrap
+import numpy as np
+from transformers import EncoderDecoderModel, RobertaTokenizer
+
+from moses.metrics.utils import QED, SA, logP, NP, weight, get_n_rings
+from moses.utils import mapper, get_mol
+
+# @st.cache(allow_output_mutation=False, hash_funcs={Tokenizer: str})
+from typing import List
+
+from util import filter_dataframe
+
+
+@st.cache(suppress_st_warning=True)
+def load_models():
+    # protein_tokenizer = RobertaTokenizer.from_pretrained("gokceuludogan/WarmMolGenTwo")
+    # mol_tokenizer = RobertaTokenizer.from_pretrained("seyonec/PubChem10M_SMILES_BPE_450k")
+    model1 = EncoderDecoderModel.from_pretrained("gokceuludogan/WarmMolGenOne")
+    model2 = EncoderDecoderModel.from_pretrained("gokceuludogan/WarmMolGenTwo")
+    return model1, model2  # , protein_tokenizer, mol_tokenizer
+
+
+def count(smiles_list: List[str]):
+    counts = []
+    for smiles in smiles_list:
+        counts.append(len(smiles))
+
+    return counts
+
+
+def remove_none_elements(mol_list, smiles_list):
+    filtered_mol_list = []
+    filtered_smiles_list = []
+    indices = []
+    for i, element in enumerate(mol_list):
+        if element is not None:
+            filtered_mol_list.append(element)
+        else:
+            indices.append(i)
+    removed_len = len(indices)
+
+    for i in range(len(smiles_list)):
+        if i not in indices:
+            filtered_smiles_list.append(smiles_list.__getitem__(i))
+
+    return filtered_mol_list, filtered_smiles_list, removed_len
+
+
+def format_list_numbers(lst):
+    for i, value in enumerate(lst):
+        lst[i] = float("{:.3f}".format(value))
+
+
+def generate_molecules(model_name, num_mols, max_new_tokens, do_sample, num_beams, target, pool):
+    protein_tokenizer = RobertaTokenizer.from_pretrained("gokceuludogan/WarmMolGenTwo")
+    mol_tokenizer = RobertaTokenizer.from_pretrained("seyonec/PubChem10M_SMILES_BPE_450k")
+    # model1, model2, protein_tokenizer, mol_tokenizer = load_models()
+    model1, model2 = load_models()
+    inputs = protein_tokenizer(target, return_tensors="pt")
+
+    model = model1 if model_name == 'WarmMolGenOne' else model2
+    outputs = model.generate(**inputs, decoder_start_token_id=mol_tokenizer.bos_token_id,
+                             eos_token_id=mol_tokenizer.eos_token_id, pad_token_id=mol_tokenizer.eos_token_id,
+                             max_length=int(max_new_tokens), num_return_sequences=int(num_mols),
+                             do_sample=do_sample, num_beams=num_beams)
+    output_smiles = mol_tokenizer.batch_decode(outputs, skip_special_tokens=True)
+    st.write("### Generated Molecules")
+    # mol_list = list(map(MolFromSmiles, output_smiles))
+    # print(mol_list)
+    # QED_scores = list(map(QED.qed, mol_list))
+    # print(QED_scores)
+    # st.write(output_smiles)
+    mol_list = mapper(pool)(get_mol, output_smiles)
+    mol_list, output_smiles, removed_len = remove_none_elements(mol_list, output_smiles)
+    if removed_len != 0:
+        st.write(f"#### Note that: {removed_len} numbers of generated invalid molecules are discarded.")
+
+    QED_scores = mapper(pool)(QED, mol_list)
+    SA_scores = mapper(pool)(SA, mol_list)
+    logP_scores = mapper(pool)(logP, mol_list)
+    NP_scores = mapper(pool)(NP, mol_list)
+    weight_scores = mapper(pool)(weight, mol_list)
+
+    format_list_numbers(QED_scores)
+    format_list_numbers(SA_scores)
+    format_list_numbers(logP_scores)
+    format_list_numbers(NP_scores)
+    format_list_numbers(weight_scores)
+
+    df_smiles = pd.DataFrame(
+        {'SMILES': output_smiles, "QED": QED_scores, "SA": SA_scores, "logP": logP_scores, "NP": NP_scores,
+         "Weight": weight_scores})
+
+    return df_smiles
+
+
+def warm_molgen_demo():
+    with st.form("my_form"):
+        with st.sidebar:
+            st.sidebar.subheader("Configurable parameters")
+
+            model_name = st.sidebar.selectbox(
+                "Model Selector",
+                options=[
+                    "WarmMolGenOne",
+                    "WarmMolGenTwo",
+                ],
+                index=0,
+            )
+
+            num_mols = st.sidebar.number_input(
+                "Number of generated molecules",
+                min_value=0,
+                max_value=20,
+                value=10,
+                help="The number of molecules to be generated.",
+            )
+
+            max_new_tokens = st.sidebar.number_input(
+                "Maximum length",
+                min_value=0,
+                max_value=1024,
+                value=128,
+                help="The maximum length of the sequence to be generated.",
+            )
+            do_sample = st.sidebar.selectbox(
+                "Sampling?",
+                (True, False),
+                help="Whether or not to use sampling; use beam decoding otherwise.",
+            )
+            target = st.text_area(
+                "Target Sequence",
+                "MENTENSVDSKSIKNLEPKIIHGSESMDSGISLDNSYKMDYPEMGLCIIINNKNFHKSTG",
+            )
+            generate_new_molecules = st.form_submit_button("Generate Molecules")
+
+    num_beams = None if do_sample is True else int(num_mols)
+
+    pool = 1
+
+    if generate_new_molecules:
+        st.session_state.df = generate_molecules(model_name, num_mols, max_new_tokens, do_sample, num_beams,
+                                                 target, pool)
+    if 'df' not in st.session_state:
+        st.session_state.df = generate_molecules(model_name, num_mols, max_new_tokens, do_sample, num_beams,
+                                                 target, pool)
+    df = st.session_state.df
+
+    filtered_df = filter_dataframe(df)
+    if filtered_df.empty:
+        st.markdown(
+            """
+            <span style='color: blue; font-size: 30px;'>No molecules were found with specified properties.</span>
+        """,
+            unsafe_allow_html=True
+        )
+    else:
+        raw_html = mols2grid.display(filtered_df, height=1000)._repr_html_()
+        components.html(raw_html, width=900, height=450, scrolling=True)
+
+    st.markdown("## How to Generate")
+    generation_code = f"""
+    from transformers import EncoderDecoderModel, RobertaTokenizer
+    protein_tokenizer = RobertaTokenizer.from_pretrained("gokceuludogan/{model_name}")
+    mol_tokenizer = RobertaTokenizer.from_pretrained("seyonec/PubChem10M_SMILES_BPE_450k")
+    model = EncoderDecoderModel.from_pretrained("gokceuludogan/{model_name}")
+    inputs = protein_tokenizer("{target}", return_tensors="pt")
+    outputs = model.generate(**inputs, decoder_start_token_id=mol_tokenizer.bos_token_id,
+                             eos_token_id=mol_tokenizer.eos_token_id, pad_token_id=mol_tokenizer.eos_token_id,
+                             max_length={max_new_tokens}, num_return_sequences={num_mols}, do_sample={do_sample}, num_beams={num_beams})
+    mol_tokenizer.batch_decode(outputs, skip_special_tokens=True)
+    """
+    st.code(textwrap.dedent(generation_code))  # textwrap.dedent("".join("Halletcez")))
+
+
+st.set_page_config(page_title="WarmMolGen Demo", page_icon="🔥", layout='wide')
+st.markdown("# WarmMolGen Demo")
+st.sidebar.header("WarmMolGen Demo")
+st.markdown(
+    """
+    This demo illustrates WarmMolGen models' generation capabilities.
+    Given a target sequence and a set of parameters, the models generate molecules targeting the given protein sequence.
+    Please enter an input sequence below 👇  and configure parameters from the sidebar 👈 to generate molecules!
+    See below for saving the output molecules and the code snippet generating them!
+"""
+)
+
+warm_molgen_demo()

pages/util.py

@@ -0,0 +1,87 @@
+import pandas as pd
+import streamlit as st
+import streamlit.components.v1 as components
+from pandas.api.types import (
+    is_categorical_dtype,
+    is_datetime64_any_dtype,
+    is_numeric_dtype,
+    is_object_dtype,
+)
+
+def filter_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Adds a UI on top of a dataframe to let viewers filter columns
+
+    Args:
+        df (pd.DataFrame): Original dataframe
+
+    Returns:
+        pd.DataFrame: Filtered dataframe
+    """
+    modify = st.checkbox("Add filters")
+
+    if not modify:
+        return df
+
+    df = df.copy()
+
+    # Try to convert datetimes into a standard format (datetime, no timezone)
+    for col in df.columns:
+        if is_object_dtype(df[col]):
+            try:
+                df[col] = pd.to_datetime(df[col])
+            except Exception:
+                pass
+
+        if is_datetime64_any_dtype(df[col]):
+            df[col] = df[col].dt.tz_localize(None)
+
+    modification_container = st.container()
+
+    with modification_container:
+        limit_non_unique = 1
+        to_filter_columns = st.multiselect("Filter dataframe on", df.columns)
+        for column in to_filter_columns:
+            if df[column].dtype == 'O':  # Check if the column is of 'object' dtype (i.e., string)
+                df[column] = df[column].astype(pd.CategoricalDtype())
+            left, right = st.columns((1, 20))
+            # Treat columns with < 10 unique values as categorical
+            if is_categorical_dtype(df[column]) or df[column].nunique() < limit_non_unique:
+                user_cat_input = right.multiselect(
+                    f"Values for {column}",
+                    df[column].unique(),
+                    default=list(df[column].unique()),
+                )
+                df = df[df[column].isin(user_cat_input)]
+            elif is_numeric_dtype(df[column]):
+                _min = float(df[column].min())
+                _max = float(df[column].max())
+                step = (_max - _min) / 100
+                user_num_input = right.slider(
+                    f"Values for {column}",
+                    min_value=_min,
+                    max_value=_max,
+                    value=(_min, _max),
+                    step=step,
+                )
+                df = df[df[column].between(*user_num_input)]
+            elif is_datetime64_any_dtype(df[column]):
+                user_date_input = right.date_input(
+                    f"Values for {column}",
+                    value=(
+                        df[column].min(),
+                        df[column].max(),
+                    ),
+                )
+                if len(user_date_input) == 2:
+                    user_date_input = tuple(map(pd.to_datetime, user_date_input))
+                    start_date, end_date = user_date_input
+                    df = df.loc[df[column].between(start_date, end_date)]
+            else:
+                user_text_input = right.text_input(
+                    f"Substring or regex in {column}",
+                )
+                if user_text_input:
+                    df = df[df[column].astype(str).str.contains(user_text_input)]
+
+    return df