Upload 3 files

app.py

@@ -0,0 +1,126 @@
+import gradio as gr
+import pickle
+from mhnreact.inspect import list_models, load_clf
+from rdkit.Chem import rdChemReactions as Reaction
+from rdkit.Chem.Draw import rdMolDraw2D
+from PIL import Image, ImageDraw, ImageFont
+from ssretro_template import ssretro, ssretro_custom
+
+def custom_template_file(template: str):
+    temp = [x.strip() for x in template.split(',')]
+    template_dict = {}
+    for i in range(len(temp)):
+        template_dict[i] = temp[i]
+    with open('saved_dictionary.pkl', 'wb') as f:
+        pickle.dump(template_dict, f)
+    return template_dict
+
+
+def get_output(p):
+    rxn = Reaction.ReactionFromSmarts(p, useSmiles=False)
+    d = rdMolDraw2D.MolDraw2DCairo(800, 200)
+    d.DrawReaction(rxn, highlightByReactant=False)
+    d.FinishDrawing()
+    text = d.GetDrawingText()
+
+    return text
+
+
+def ssretro_prediction(molecule, custom_template=False):
+    model_fn = list_models()[0]
+    retro_clf = load_clf(model_fn)
+    predict, txt = [], []
+
+    if custom_template:
+        outputs = ssretro_custom(molecule, retro_clf)
+    else:
+        outputs = ssretro(molecule, retro_clf)
+
+    for pred in outputs:
+        txt.append(
+            f'predicted top-{pred["template_rank"] - 1}, template index: {pred["template_idx"]}, prob: {pred["prob"]: 2.1f}%;')
+        predict.append(get_output(pred["reaction"]))
+
+    return predict, txt
+
+
+def mhn_react_backend(mol, use_custom: bool):
+    output_dir = "outputs"
+    formatter = "03d"
+    images = []
+
+    predictions, comments = ssretro_prediction(mol, use_custom)
+
+    for i in range(len(predictions)):
+        output_im = f"{str(output_dir)}/{format(i, formatter)}.png"
+
+        with open(output_im, "wb") as fh:
+            fh.write(predictions[i])
+        fh.close()
+        font = ImageFont.truetype(r'tools/arial.ttf', 20)
+        img = Image.open(output_im)
+        right = 10
+        left = 10
+        top = 50
+        bottom = 1
+
+        width, height = img.size
+
+        new_width = width + right + left
+        new_height = height + top + bottom
+
+        result = Image.new(img.mode, (new_width, new_height), (255, 255, 255))
+        result.paste(img, (left, top))
+
+        I1 = ImageDraw.Draw(result)
+        I1.text((20, 20), comments[i], font=font, fill=(0, 0, 0))
+        images.append(result)
+        result.save(output_im)
+
+    return images
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        __[Github](https://github.com/ml-jku/mhn-react)__  
+        __[acs.jcim](https://pubs.acs.org/doi/10.1021/acs.jcim.1c01065)__
+        __[Google Colab](https://colab.research.google.com/github/ml-jku/mhn-react/blob/main/notebooks/colab_MHNreact_demo.ipynb)__
+        ### MHN-react   
+        Adapting modern Hopfield networks (Ramsauer et al., 2021) (MHN) to associate different data modalities,
+        molecules and reaction templates, to improve predictive performance for rare templates and single-step retrosynthesis.
+        """
+    )
+
+    with gr.Accordion("Guide"):
+        gr.Markdown("Information (add) <br> "
+                    "In case the output is empty => No suitable templates?"
+                    "use one of example molecules: <br> CC(=O)NCCC1=CNc2c1cc(OC)cc2"
+                    )
+
+    with gr.Tab("Generate Templates"):
+        with gr.Row():
+            with gr.Column(scale = 1):
+                inp = gr.Textbox(placeholder="Input molecule in SMILES format", label="input molecule")
+                radio = gr.Radio([False, True], label="use custom templates")
+
+                btn = gr.Button(value="Generate")
+
+            with gr.Column(scale=2):
+                out = gr.Gallery(label="retro-synthesis")
+
+        btn.click(mhn_react_backend, [inp, radio], out)
+
+    with gr.Tab("Create custom templates"):
+        gr.Markdown(
+            """
+            Input the templates separated by comma. <br> Please do not upload templates one-by-one
+            """
+        )
+        with gr.Column():
+            inp_t = gr.Textbox(placeholder="custom template", label="add custom template(s)")
+            btn = gr.Button(value="upload")
+            out_t = gr.Textbox(label = "added templates")
+            btn.click(custom_template_file, inp_t, out_t)
+
+demo.launch()

saved_dictionary.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87ccfca32bc3f8a4bad6c3fe20b97d47bb0f55f4913920b4f8c707d8b4e3344e
+size 766

ssretro_template.py

@@ -0,0 +1,146 @@
+from rdkit.Chem import AllChem
+from mhnreact.data import load_dataset_from_csv
+from mhnreact.molutils import convert_smiles_to_fp
+from rdchiral.main import rdchiralRun, rdchiralReaction, rdchiralReactants
+import torch
+import pickle
+
+reaction_superclass_names = {
+    1: 'Heteroatom alkylation and arylation',
+    2: 'Acylation and related processes',
+    3: 'C-C bond formation',
+    4: 'Heterocycle formation',  # TODO check
+    5: 'Protections',
+    6: 'Deprotections',
+    7: 'Reductions',
+    8: 'Oxidations',
+    9: 'Functional group interconversoin (FGI)',
+    10: 'Functional group addition (FGA)'
+}
+
+def getTemplateApplicabilityMatrix(t, fp_size=8096, fp_type='pattern'):
+    only_left_side_of_templates = list(map(lambda k: k.split('>>')[0], t.values()))
+    return convert_smiles_to_fp(only_left_side_of_templates, is_smarts=True, which=fp_type, fp_size=fp_size)
+
+
+def FPF(smi, templates, fp_size=8096, fp_type='pattern'):
+    """Fingerprint-Filter for applicability"""
+    tfp = getTemplateApplicabilityMatrix(templates, fp_size=fp_size, fp_type=fp_type)
+    if not isinstance(smi, list):
+        smi = [smi]
+    mfp = convert_smiles_to_fp(smi, which=fp_type, fp_size=fp_size)
+    applicable = ((tfp & mfp).sum(1) == (tfp.sum(1)))
+    return applicable
+
+
+def ssretro(target_smiles: str, clf, num_paths=5, try_max_temp=10, viz=False, use_FPF=False):
+    """single-step-retrosynthesis"""
+    X, y, t, test_reactants_can = load_dataset_from_csv('data/USPTO_50k_MHN_prepro.csv.gz', ssretroeval=True)
+    if hasattr(clf, 'templates'):
+        if clf.X is None:
+            clf.X = clf.template_encoder(clf.templates)
+    preds = clf.forward_smiles([target_smiles])
+
+    if use_FPF:
+        appl = FPF(target_smiles, t)
+        preds = preds * torch.tensor(appl)
+    preds = clf.softmax(preds)
+
+    idxs = preds.argsort().detach().numpy().flatten()[::-1]
+    preds = preds.detach().numpy().flatten()
+
+    try:
+        prod_rct = rdchiralReactants(target_smiles)
+    except:
+        print('target_smiles', target_smiles, 'not computable')
+        return []
+    reactions = []
+
+    i = 0
+    while len(reactions) < num_paths and (i < try_max_temp):
+        resu = []
+        while (not len(resu)) and (i < try_max_temp):  # continue
+            # print(i, end='  \r')
+            try:
+                rxn = rdchiralReaction(t[idxs[i]])
+                resu = rdchiralRun(rxn, prod_rct, keep_mapnums=True, combine_enantiomers=True, return_mapped=True)
+            except:
+                resu = ['err']
+            i += 1
+
+        if len(resu) == 2:  # if there is a result
+            res, mapped_res = resu
+
+            rs = [AllChem.MolToSmiles(prod_rct.reactants) + '>>' + k[0] for k in list(mapped_res.values())]
+            for r in rs:
+                di = {
+                    # 'template_used': t[idxs[i]],
+                    'template_idx': idxs[i],
+                    'template_rank': i + 1,  # get the acutal rank, not the one without non-executable
+                    'reaction': r,
+                    'prob': preds[idxs[i]] * 100
+                }
+                # di['template_num_train_samples'] = (y['train'] == di['template_idx']).sum()
+                reactions.append(di)
+            if viz:
+                for r in rs:
+                    print('with template #', idxs[i], t[idxs[i]])
+                    # smarts2svg(r, useSmiles=True, highlightByReactant=True);
+
+    return reactions
+
+def ssretro_custom(target_smiles: str, clf, num_paths=5, try_max_temp=10, viz=False, use_FPF=False):
+    """single-step-retrosynthesis"""
+    # X, y, t, test_reactants_can = load_dataset_from_csv('data/USPTO_50k_MHN_prepro.csv.gz', ssretroeval=True)
+    with open('saved_dictionary.pkl', 'rb') as f:
+        t = pickle.load(f)
+
+    if hasattr(clf, 'templates'):
+        if clf.X is None:
+            clf.X = clf.template_encoder(clf.templates)
+    preds = clf.forward_smiles([target_smiles])
+
+    if use_FPF:
+        appl = FPF(target_smiles, t)
+        preds = preds * torch.tensor(appl)
+    preds = clf.softmax(preds)
+
+    idxs = preds.argsort().detach().numpy().flatten()[::-1]
+    preds = preds.detach().numpy().flatten()
+
+    try:
+        prod_rct = rdchiralReactants(target_smiles)
+    except:
+        print('target_smiles', target_smiles, 'not computable')
+        return []
+    reactions = []
+
+    i = 0
+    while len(reactions) < num_paths and (i < try_max_temp):
+        resu = []
+        while (not len(resu)) and (i < try_max_temp):  # continue
+            # print(i, end='  \r')
+            try:
+                rxn = rdchiralReaction(t[idxs[i]])
+                resu = rdchiralRun(rxn, prod_rct, keep_mapnums=True, combine_enantiomers=True, return_mapped=True)
+            except:
+                resu = ['err']
+            i += 1
+
+        if len(resu) == 2:  # if there is a result
+            res, mapped_res = resu
+
+            rs = [AllChem.MolToSmiles(prod_rct.reactants) + '>>' + k[0] for k in list(mapped_res.values())]
+            for r in rs:
+                di = {
+                    # 'template_used': t[idxs[i]],
+                    'template_idx': idxs[i],
+                    'template_rank': i + 1,  # get the acutal rank, not the one without non-executable
+                    'reaction': r,
+                    'prob': preds[idxs[i]] * 100
+                }
+                reactions.append(di)
+            if viz:
+                for r in rs:
+                    print('with template #', idxs[i], t[idxs[i]])
+    return reactions