{"id":10688,"date":"2024-01-02T13:08:43","date_gmt":"2024-01-02T13:08:43","guid":{"rendered":"https:\/\/www.blopig.com\/blog\/?p=10688"},"modified":"2024-04-18T09:45:57","modified_gmt":"2024-04-18T08:45:57","slug":"finding-and-testing-a-reaction-smarts-pattern-for-any-reaction","status":"publish","type":"post","link":"https:\/\/www.blopig.com\/blog\/2024\/01\/finding-and-testing-a-reaction-smarts-pattern-for-any-reaction\/","title":{"rendered":"Finding and testing a reaction SMARTS pattern for any reaction"},"content":{"rendered":"\n

Have you ever needed to find a reaction SMARTS pattern for a certain reaction but don’t have it already written out? Do you have a reaction SMARTS pattern but need to test it on a set of reactants and products to make sure it transforms them correctly and doesn’t allow for odd reactants to work? I recently did and I spent some time developing functions that can:<\/p>\n\n\n\n

    \n
  1. Generate a reaction SMARTS for a reaction given two reactants, a product, and a reaction name.<\/li>\n\n\n\n
  2. Check the reaction SMARTS on a list of reactants and products that have the same reaction name.<\/li>\n<\/ol>\n\n\n\n\n\n\n\n

    What is SMARTS?<\/h3>\n\n\n\n

    SMARTS stands for SMiles ARbitrary Target Specification, and is a language used for pattern searching in molecules. It was invented by Daylight and they have much more information on their site here<\/a>. Reaction SMARTS are SMARTS used to define reactions, they will usually have this basic structure:<\/p>\n\n\n\n

    [reactant_1].[reactant_N]>>[product_1].[product_N]<\/pre>\n\n\n\n
    For the rest of the functions you’ll need to install and import the neccessary libraries.<\/p>\n\n\n\n
    !pip install reaction-utils rxnmapper rdkit\n\nfrom rxnutils.chem.reaction import ChemicalReaction\nfrom rxnmapper import RXNMapper\nfrom rdkit import Chem\nfrom rdkit.Chem import AllChem, DataStructs, Draw<\/pre>\n\n\n\n
    Example 1:<\/strong> Generate a reaction SMARTS given the reactants and product<\/h2>\n\n\n\n
    Let’s say we need a reaction smarts for the bimolecular reaction, reductive amination. I have these two reactants and product. <\/p>\n\n\n\n
    reactant1 = Chem.MolFromSmiles('O=Cc1ccc2c(c1)OCO2')\nreactant2 = Chem.MolFromSmiles('Cc1nnc2c(N)nccn12')\nproduct = Chem.MolFromSmiles('Cc1nnc2c(NCc3ccc4c(c3)OCO4)nccn12')\ncaptions = ['Reactant 1', 'Reactant 2', 'Product']\nDraw.MolsToGridImage([reactant1, reactant2, product], molsPerRow=3, subImgSize=(300,300), legends=captions)<\/pre>\n\n\n\n
    \"\"<\/a><\/figure>\n\n\n\n
    Now lets define the make_rxn_template<\/code> function, which takes the two reactant mol objects, product mol object, and radius for the reaction template search as inputs. The radius argument specifies the radius of the template. It uses RXNmapper<\/a> which labels exact atoms in the reactants that are kept in the product. Steph (another lovely OPIG member) wrote a helpful post on this tool, check it out<\/a>! 

    This make_rxn_template<\/code> function outputs the SMARTS reaction template. <\/p>\n\n\n\n
    def make_rxn_template(reactants: list, product: Chem.Mol, radius=1):\n    \"\"\"\n    Given mol objects of two reactants and product, make a SMARTS reaction template.\n    \"\"\"\n    reactants = [Chem.MolToSmiles(reactant) for reactant in reactants]\n    product = Chem.MolToSmiles(product)\n    # Make string of reaction\n    reaction = f\"{reactants[0]}.{reactants[1]}>>{product}\"\n    rxnmapper = RXNMapper()\n    # Get atom mapped forward template\n    res = rxnmapper.get_attention_guided_atom_maps([reaction])[0]\n    # Convert to ChemicalReaction object\n    rxn = ChemicalReaction(res['mapped_rxn'])\n    # Get reaction templates with radius\n    mapping = rxn.generate_reaction_template(radius=radius, expand_ring=False, expand_hetero=False)\n    forward_template = mapping[0].smarts\n    return forward_template<\/pre>\n\n\n\n
    # create reaction SMARTS\nfirst_reductive_amination_mapping = make_rxn_template(reactants, product, radius=1)\nprint(first_reductive_amination_mapping)<\/pre>\n\n\n\n
    'O=[CH;D2;+0:1]-[c:2].[#7;a:3]:[c:4](-[NH2;D1;+0:5]):[c:6](:[#7;a:7]):[#7;a:8]>>[#7;a:3]:[c:4](-[NH;D2;+0:5]-[CH2;D2;+0:1]-[c:2]):[c:6](:[#7;a:7]):[#7;a:8]'<\/code><\/pre>\n\n\n\n
    Great, that is our reaction SMARTS for reductive amination! To check if this reaction SMARTS will work for other reductive amination examples lets test it in Example 2. <\/p>\n\n\n\n
    Example 2: Check a reaction SMARTS on many reaction examples<\/h2>\n\n\n\n
    Now we need to check if this SMARTS works for other examples of this same reaction in our dataset. I have a dataframe of 10 other reductive amination examples that looks like this:<\/p>\n\n\n\n\n  \n    \n      \n    \n      \n      \n      \n      \n      \n      \n      \n      \n      \n      
    product<\/th>\n      reactants<\/th>\n      name<\/th>\n    <\/tr>\n  <\/thead>\n  
    Cc1nnc2c(NCc3ccc4c(c3)OCO4)nccn12<\/td>\n      (O=Cc1ccc2c(c1)OCO2, Cc1nnc2c(N)nccn12)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    O[C@@H](CNCc1nnc2ccccn12)c1ccc2c(c1)OCO2<\/td>\n      (O=Cc1nnc2ccccn12, NCC(O)c1ccc2c(c1)OCO2)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    Cc1cc(C(=O)N[C@H](C)[C@H](C)NCc2ccccn2)no1<\/td>\n      (O=Cc1ccccn1, Cc1cc(C(=O)NC(C)C(C)N)no1)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    CCOC(=O)C[C@@H](c1cc(C)on1)N1CCCCC1<\/td>\n      (CCOC(=O)CC(=O)c1cc(C)on1, C1CCNCC1)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    C[C@@H](F)CCNC1CCN(C(=O)CCN2CCCCC2)CC1<\/td>\n      (O=C1CCN(C(=O)CCN2CCCCC2)CC1, CC(F)CCN)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    c1cncc([C@@H]2CCC[C@@H](NCc3ccc4c(c3)OCO4)C2)c1<\/td>\n      (O=C1CCCC(c2cccnc2)C1, NCc1ccc2c(c1)OCO2)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    COc1cccc(CN[C@H](Cc2ccc3c(c2)OCO3)C(=O)O)n1<\/td>\n      (NC(Cc1ccc2c(c1)OCO2)C(=O)O, COc1cccc(C=O)n1)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    Cc1cc(C(=O)NCC[C@@H](C)NCC(=O)N2CCCCC2)no1<\/td>\n      (NCC(=O)N1CCCCC1, CC(=O)CCNC(=O)c1cc(C)on1)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    FC(F)(F)C(F)(F)[C@@H]1CCCN(CCCN2CCCCC2)C1<\/td>\n      (O=CCCN1CCCCC1, FC(F)(F)C(F)(F)C1CCCNC1)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n    
    CC(C)(C)c1cncc(CN[C@@H](CN2CCCCC2)C(=O)O)c1<\/td>\n      (NC(CN1CCCCC1)C(=O)O, CC(C)(C)c1cncc(C=O)c1)<\/td>\n      Reductive_amination<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n\n\n
    Here I define the following functions to test my generated reductive amination template  on my examples. Basically check_smarts<\/code> is the entry function that takes the dataframe of the product and reactants as SMILES as input. For each row in the dataframe check_rxn_template_works<\/code> applies the given reaction template to reactants and product using check_rxn<\/code>. Both combinations of reactants are checked since the order is specific for each reaction template. <\/p>\n\n\n\n
    The check_rxn<\/code> function applies the reaction SMARTS to the reactants and if a product is found, that product is checked if it matches the original product by tanimoto similarity = 1. There are three possible outputs from check_rxn<\/code>:<\/p>\n\n\n\n
      \n
    1. The reaction SMARTS is applicable and produces the expected product with Tanimoto similarity of 1.0.<\/li>\n\n\n\n
    2. The reaction SMARTS is applicable but does not produce any of the expected products with Tanimoto similarity of 1.0.<\/li>\n\n\n\n
    3. The reaction SMARTS is not applicable to the provided reactants, therefore there is no product. <\/li>\n<\/ol>\n\n\n\n
      \"\"\"\nThis code block contains functions for reaction enumeration and reaction mapping. NOTE: This is intended to be run in a jupyter notebook, hence the use of the display() functionality.\n\"\"\"\ndef remove_chirality(smiles: str):\n    return smiles.replace('@@', '').replace('@', '').replace('\/', '').replace('\\\\', '')\n\ndef check_rxn(rxn: AllChem.ChemicalReaction, reactants: list, products: list, verbose=False):\n    \"\"\"\n    Check if reaction template works for a combination of reactants\n    using Tanimoto similarity to compare against a list of products.\n    \n    INPUT:\n        rxn: AllChem.ReactionSmarts object\n        reactants: list of mol objects of reactants\n        products: list of smiles of possible products\n    \"\"\"\n    predicted_products_flat = []\n    if rxn.RunReactants(reactants):\n        predicted_products_list = rxn.RunReactants(reactants)\n        predicted_products_flat = [remove_chirality(Chem.MolToSmiles(mol)) for product_set in predicted_products_list for mol in product_set]\n        # Check Tanimoto similarity with each product in the provided list\n        for predicted_smiles in predicted_products_flat:\n            predicted_product_mol = Chem.MolFromSmiles(predicted_smiles)\n            predicted_product_fp = AllChem.GetMorganFingerprint(predicted_product_mol, 2)\n            for product_smiles in products:\n                product_mol = Chem.MolFromSmiles(product_smiles)\n                product_fp = AllChem.GetMorganFingerprint(product_mol, 2)\n                similarity = DataStructs.TanimotoSimilarity(product_fp, predicted_product_fp)\n                if similarity == 1.0:\n                    if verbose:\n                        print(\"The reaction SMARTS is applicable and produces the expected product with Tanimoto similarity of 1.0.\")\n                    return 1, predicted_products_flat\n        if verbose:\n            print(\"The reaction SMARTS is applicable but does not produce any of the expected products with Tanimoto similarity of 1.0.\")\n        return -1, predicted_products_flat\n    else:\n        if verbose:\n            print(\"The reaction SMARTS is not applicable to the provided reactants, therefore there is no product.\")\n        return 0, predicted_products_flat\n\ndef check_rxn_template_works(rxn_temp: str, reactants: list, products: list, verbose=False):\n    \"\"\"\n    Check if reaction template works. LOOKS AT BOTH COMBINATIONS OF REACTANTS.\n    \"\"\"\n    rxn = AllChem.ReactionFromSmarts(rxn_temp)\n    reactants = [Chem.MolFromSmiles(reactant) for reactant in reactants]\n    products = [remove_chirality(product) for product in products]\n    AllChem.SanitizeRxn(rxn)\n    outcome = 0\n    # Check if the number of reactants is applicable\n    if len(reactants) != len(rxn.GetReactants()):\n        if verbose: print(\"The reaction SMARTS is not applicable to the provided reactants.\")\n        return 0, []\n    # Check if the reaction is applicable to both combinations of reactants\n    if verbose: print('Outcome of first combo:')\n    outcome, predicted_products_flat = check_rxn(reactants=reactants, rxn=rxn, products=products, verbose=verbose)\n    if len(reactants) == 1:\n        return outcome, predicted_products_flat\n    reactants2 = [reactants[1], reactants[0]]\n    if verbose: print('Outcome of second combo:')\n    outcome2, predicted_products_flat2 = check_rxn(reactants=reactants2, rxn=rxn, products=products, verbose=verbose)\n    predicted_products_flat2\n    if outcome == 1 or outcome2 == 1:\n        outcome = 1\n        predicted_products_flat.extend(predicted_products_flat2)\n        return outcome, predicted_products_flat\n    if outcome == -1 or outcome2 == -1:\n        outcome = -1\n        predicted_products_flat.extend(predicted_products_flat2)\n        return outcome, predicted_products_flat\n    else:\n        outcome = 0\n        predicted_products_flat.extend(predicted_products_flat2)\n        return outcome, predicted_products_flat\n\ndef check_smarts(df: pd.DataFrame, rxn_smarts: str):\n    success = 0\n    failure = 0\n    total = len(df)\n    for index, row in df.iterrows():\n        reactants = row['reactants']\n        product = [row['product']]\n        print('ROW:', index)\n        outcome = check_rxn_template_works(rxn_smarts, reactants, product, verbose=True)\n        if outcome[0] != 1:\n            failure += 1\n            if outcome[0] == -1:\n                print('FAILED: THE PREDICTED PRODUCT(S) IS\/ARE WRONG')\n                for i in outcome[1]:\n                    display(Chem.MolFromSmiles(i))\n            if outcome[0] == 0:\n                print('FAILED: THE REACTION SMARTS IS NOT APPLICABLE TO THE PROVIDED REACTANTS')\n            print('REACTANT(S) BELOW:')\n            display(Chem.MolFromSmiles(reactants[0]))\n            display(Chem.MolFromSmiles(reactants[1]))\n            print('PROPER PRODUCT(S) BELOW')\n            products = [Chem.MolFromSmiles(i) for i in product]\n            for i in products:\n                display(i)\n        else:\n            success += 1\n            print('SUCCESS: THE PREDICTED PRODUCT(S) IS\/ARE RIGHT')\n            for i in outcome[1]:\n                display(Chem.MolFromSmiles(i))\n    print(f'SUCCESS: {success} \/ {total} ({(success\/len(df)*100)}%)')\n    print(f'FAILURE: {failure} \/ {total} ({failure\/len(df)*100}%)')<\/pre>\n\n\n\n
      check_smarts(df, first_reductive_amination_mapping)<\/pre>\n\n\n\n
      \"\"<\/a><\/figure>\n\n\n\n
      \"\"<\/a><\/figure>\n\n\n\n
      \"\"<\/a><\/figure>\n\n\n\n
      Etc…<\/p>\n\n\n\n
      \"\"<\/a><\/figure>\n\n\n\n
      These results mean the reaction template only worked for one example (the one it was originally generated for) and did not work for any other examples \ud83d\ude25. While not a great result, this is most likely due to its high specificity. <\/p>\n\n\n\n
      After some manual editing using the helpful SMARTS visualization tool SMARTS PLUS<\/a>, made by the University of Hamburg, we have a more general reductive amination template.<\/p>\n\n\n\n
      first_reductive_amination = 'O=[CH;D2;+0:1]-[c:2].[#7;a:3]:[c:4](-[NH2;D1;+0:5]):[c:6](:[#7;a:7]):[#7;a:8]>>[#7;a:3]:[c:4](-[NH;D2;+0:5]-[CH2;D2;+0:1]-[c:2]):[c:6](:[#7;a:7]):[#7;a:8]'\n\ngeneral_reductive_amination_mapping = '[#6:2](=[#8])(-[#6:1]).[#7;H2,H1:3]>>[#6:2](-[#6:1])-[#7:3]'<\/pre>\n\n\n\n
      check_smarts(df, general_reductive_amination_mapping)<\/pre>\n\n\n\n
      \"\"<\/a><\/figure>\n\n\n\n
      Success!!<\/p>\n\n\n\n
      Acknowledgements<\/h3>\n\n\n\n
      Please check out these tools that were indespensible for this! <\/p>\n\n\n\n