Generative models hold great promise for small molecule discovery, significantly increasing the size of search space compared to traditional in silico screening libraries. However, most existing machine learning methods for small molecule generation suffer from poor synthesizability of candidate compounds, making experimental validation difficult. In this paper we propose Reaction-GFlowNet (RGFN), an extension of the GFlowNet framework that operates directly in the space of chemical reactions, thereby allowing out-of-the-box synthesizability while maintaining comparable quality of generated candidates. We demonstrate that with the proposed set of reactions and building blocks, it is possible to obtain a search space of molecules orders of magnitude larger than existing screening libraries coupled with low cost of synthesis. We also show that the approach scales to very large fragment libraries, further increasing the number of potential molecules. We demonstrate the effectiveness of the proposed approach across a range of oracle models, including pretrained proxy models and GPU-accelerated docking.
Paper
Similar papers
Peer review
Summary
This study modifies prior GFlowNet-based frameworks to produce molecules satisfying synthesizability. While previous GFlowNet-based molecular generation completes molecules by adding fragments or atoms, the proposed method repeats following stems to generate molecules: (1) selects reaction templates, (2) selects reactants, and (3) performs reactions and selects one of the resulting molecules. In the experiments, the proposed method shows competitive performance while preserving synthesizability.
Strengths
- The proposed method first incorporates a reaction-based generation framework with GFlowNet for synthesizability. - A chemical language for synthesizability seems to offer cost advantages in real-world applications, demonstrating that it acts as a promising inductive bias to generate promising molecules. - The proposed method shows competitive performance compared to (1) FGFN in terms of synthesizability and (2) SyntheMol in terms of average reward and mode discovery. Although it finds fewer modes compared to FGFN, this seems to stem from constraints in the generation space.
Weaknesses
- The preliminary is insufficient for understanding the components of the method, particularly mentioning the flow matching condition while the method section actually describes forward and backward policy. - To improve synthesizability-related metrics, one may consider including them in the rewards. Can authors provide a comparison with FGFN including the SA score in the reward? (e.g., multiobjective GFN) - The lower number of modes in RGFN (compared to FGFN) is due to constraints in the generation space (ensure high SA scores). Therefore, it would be interesting to compare the number of modes filtered by SA scores. - Can authors compare the cost of generation time? Additionally, I am curious about time costs for (finding a synthesizability path + generation with FGFN) vs. (generation with RGFN). **Minor:** - Error in line 114 $m'i$
Questions
See weaknesses.
Rating
6
Confidence
3
Soundness
3
Presentation
2
Contribution
3
Limitations
The authors have acknowledged the limitations of their approach.
Thank you for the detailed and informative clarification. Most of my concerns are resolved. I believe that the paper has a basic value to be accepted. Therefore, I'd like to increase my score (5->6).
Summary
This paper presents a model for molecule design called Reaction-GFlowNet (RGFN). RGFN is an extension of the GFlowNet framework [4] (which has previously been used to generate molecules by building them out of small fragments) to generate molecules through virtual chemical reactions, ensuring that the molecules RGFN generates are more likely to be synthesizable. The paper evaluates RGFN against GraphGA (a graph genetic algorithm), FGFN (the original fragment-based GFlowNet), and SyntheMol (a recent synthesis-based generative model of molecules proposed in [54] based around Monte Carlo tree search). The paper shows RGFN finds competitively scoring molecules on two proxy* and one docking task (as expected the unconstrained GraphGA does best), while also ensuring the molecules it suggests do better on important synthesizability metrics. * proxy meaning the task is to optimize against a graph neural network (GNN) oracle trained on a small amount of target data. (Edited Aug 14 to update the score: see comments below).
Strengths
## Summary of review This paper addresses one of the limitations of GFlowNets by explicitly incorporating synthesis plans into the molecular generative process. However, this seems to be a fairly straightforward extension of the GFlowNets framework with synthesis-based generative models of molecules proposed elsewhere. The experiments in this paper compare the proposed method against only one of these existing models. ## Originality/Significance RFGN is an extension of GFlowNets [4] to build molecules through chemical reactions rather than through combining small molecular fragments. This addresses a key limitation with the original GFlowNet, which the experiments show often generates molecules for which no synthetic route can be found. Having said that, there have been many synthesis-based generative models of molecules proposed (e.g., [8,17,54,19,22] and others not cited -- see below), and RGFN seems a fairly straightforward combination of these ideas with GFlowNets. > Korovina, K., Xu, S., Kandasamy, K., Neiswanger, W., Poczos, B., Schneider, J. and Xing, E. (2020) ‘ChemBO: Bayesian Optimization of Small Organic Molecules with Synthesizable Recommendations’, in International Conference on Artificial Intelligence and Statistics. AISTATS 2020 > Nguyen, D.H. and Tsuda, K. (2022) ‘Generating reaction trees with cascaded variational autoencoders’, The Journal of chemical physics, 156(4), p. 044117. > Vinkers, H.M., de Jonge, M.R., Daeyaert, F.F.D., Heeres, J., Koymans, L.M.H., van Lenthe, J.H., Lewi, P.J., Timmerman, H., Van Aken, K. and Janssen, P.A.J. (2003) ‘SYNOPSIS: SYNthesize and OPtimize System in Silico’, Journal of medicinal chemistry, 46(13), pp. 2765–2773. > Button, A., Merk, D., Hiss, J.A. and Schneider, G. (2019) ‘Automated de novo molecular design by hybrid machine intelligence and rule-driven chemical synthesis’, Nature Machine Intelligence, 1(7), pp. 307–315. ## Quality The optimization tasks done to evaluate RGFN seem interesting and it's nice to see the molecules suggested also evaluated in terms of their diversity and synthesizability (using a retrosynthesis planner). While I think it is great that the tasks were more complicated than some of the simple ones often used elsewhere, it might have been nice to include some more commonly-used (yet still challenging) benchmarks too (such as the Therapeutics Data Commons benchmark -- citation below). This would make comparisons with existing models easier. > Kexin Huang, Tianfan Fu, Wenhao Gao, Yue Zhao, Yusuf Roohani, Jure Leskovec, Connor W Coley, Cao Xiao, Jimeng Sun, and Marinka Zitnik. Therapeutics data commons: machine learning datasets and tasks for therapeutics. arXiv preprint arXiv:2102.09548, 2021. ## Clarity Overall I thought the paper was well-written and easy to follow. In particular, I thought Section 3.2 was helpful in giving an overview of the approach (along with the informative Figure 1), and Equations 2–7 were helpful in explaining the parameterizations of the various networks involved. The experiments also seemed to be clearly presented. Readers unfamiliar with GFlowNets [4] would likely have to read about them elsewhere (lines 70–82 provide a short, although limited introduction). However, this seems reasonable due to the overall space available.
Weaknesses
## Originality As mentioned under the originality/significance heading in the section above, RGFN seems a fairly straightforward combination of the ideas of GFlowNets with recent synthesis-based generative models of molecules. It would have been helpful if there had been more focus on why synthesis-based GFlowNets were a better approach to take than the currently proposed alternatives to better promote the paper's significance. (Hence why I have gone with a low contribution score). ## Only one other synthesis-based generative model of molecules is compared against The only other synthesis-based generative model for molecules that is compared against in the experiments is SyntheMol, and this baseline has been limited here in the amount of compute it uses. I can understand no comparison is done against [22,19] due to the lack of open-sourced code, but it would have been nice to have had a comparison against some of the other ones cited, e.g., [17] with its open sourced code available on GitHub (https://github.com/wenhao-gao/SynNet). It would also be nice to have a comparison to the other mentioned methods for encouraging synthesizability, e.g. via using scoring methods [34]. (This along with the fact that no code is available -- see below -- is why I have gone with a lower soundness score). ## No code is shared As far as I'm aware there is no code currently available for RGFN? It does not seem to be provided as part of the submission (despite this box being ticked in the paper checklist)? I would find it impossible to reproduce the results of the paper using the details provided in Appendices B-D alone (e.g., I'm unsure of what building blocks and reaction templates to use or even how the molecules fed into the GNNs were featurized). One of the proxies was initially trained in an unsupervised manner on the ZINC dataset (Appendix B), but there are scant details on how this was done. On a similar note, the compute resources used to train the models also seems to be missing. This is again marked as included in the paper checklist, so would appreciate being pointed towards this if I have made a mistake and missed this? ## Method is currently limited to a restricted synthetic space RGFN uses only 350 building blocks and 17 reactions. This is low compared to the ~150k building blocks and 49 reactions used in [19], or the 5000 building blocks and 90 reactions used in [22]. The experiments done in Section 4.3 suggests the RGFN scales badly to larger building block libraries even with architecture modifications and larger reaction libraries do not seem to have been tried. This, combined with the fact that RFGN can only explore linear synthetic trees (i.e., multiple complex intermediates cannot be created and then combined) and bimolecular reactions restricts the molecules that the approach could explore. This might be an issue in more challenging optimization tasks.
Questions
1. What is the distribution of the number of reaction steps typically used when finding useful molecules? 2. I don't completely follow how the size of the state space was calculated in Figure 2. Perhaps a cartoon would be useful in Appendix A. Is the state space size different to the total number of unique molecules that can be generated? 3. I'm confused as to why RGFN seems to often outperform FGFN in the docking/proxy scores of the molecules it finds. I would have thought the latter model is more flexible and so should be able to find better scoring molecules, even if they did not end up being synthesizable. The paper suggests that the library of fragments available for RGFN might be less suitable than those found in the building blocks picked for RGFN. Have different fragments been tried or other experiments carried out to investigate this hypothesis? 4. RGFN seems to produce molecules with lower QED scores than SyntheMol and FGFN: is there any intuition for why this might be the case? 5. Line 243 says: > "All RGFN modes were additionally inspected manually by a chemist and confirmed as synthesizable, which indicates that AiZynth scores are likely underestimated." Does this mean that a chemist took the proposed molecule and synthesized it in the lab? Were the proposed synthetic routes from RGFN used or were alternatives derived? 6. Line 282 states: > "It is also important to recognize that RGFN does not explicitly generate synthetic routes to the molecules." I did not understand what was meant by this. I thought the whole point of RGFN is that it did explicitly generate synthetic routes to the final molecule through the sampled trajectory? 7. Equation 4 versus 7: a. My understanding is that the architecture expressed in Equation 4 is used instead of that of Equation 7 (apart from in Section 4.3)? b. The architecture expressed in Equation 7 seems to do better in Figure 5 so why not always use this? c. Could also a similar principle be used to scale up the number of reaction templates available? 8. Line 221 discusses a procedure for picking molecular modes from the list of proposed molecules. Given modes have to be a certain Tanimoto distance apart, I assume this procedure is run greedily and is somewhat dependent on how the molecules are ordered?
Rating
6
Confidence
4
Soundness
2
Presentation
3
Contribution
2
Limitations
Two limitations are discussed in Section 5: (i) that the model is currently limited to a very small reaction and building block library, and (ii) the issues inherent with docking oracles. Regarding the first of these, the authors discuss and evaluate a modification of the architecture to try to enable the method to scale (see Section 4.3), but performance still degrades as the initial fragment library increases and so this seems to remain an outstanding limitation (see also the weaknesses section above). The second limitation (docking oracles are not perfect) is not limited to RGFN and is a problem among similar models more generally. The authors discuss incorporating additional, more-accurate oracles in a multi-fidelity framework to resolve this which seems reasonable. Another limitation which is not discussed is the sample efficiency of the proposed approach (which is again also a limitation for the baselines). The number of molecules the non-GFlowNet baselines visit during optimization for the different tasks is described in Section 4. These are high and range from 70k-400k, and I would be interested in how this compares to the two GFlowNet models.
Thanks for discussion and further results
Thank you for following up. Yes, while I agree your curated set of reactions and fragments could be an interesting contribution, currently it is hard for me to judge given that they are not actually included in the submission (related to point W3). I believe (from the initial rebuttal) you have provided this to the AC though (note I cannot see the AC comment) so leave it with them. Anyway, I have edited my score to reflect many of my original points getting addressed and to reflect the additional experiments carried out (including the one recently posted), showing that the diversity of the produced molecules could be a reason to prefer the approach here over other previously proposed synthesis-based de novo design methods. Thanks also for the discussion!
Summary
This work proposes a GFlowNet-based framework for synthesizable molecule design, which comprises of building block selection stages and reaction selection stages. The GFlowNet-based model uses chemical oracle functions as reward and the goal is to generate synthesizable molecules with the desired property quantified by the scoring function.
Strengths
- This work tackles the synthesizability challenge in molecular design, which is crucial to experimental validation but has been long overlooked by previous work on molecular generation. - Molecular synthesis pathways have been represented by directed acyclic graphs, which fit well the structure of GFlowNet sampling process. Therefore, this work choosing GFlowNet as the framework is proper and well-motivated. - The experimental study is comprehensive. It demonstrates that RGFN can produce synthesizable molecules with higher docking score. It also examines the diversity and docking structures of the generated molecules
Weaknesses
- As acknowledged in the paper, the major limitation is scalability to a larger chemical space. It becomes much more difficult to discover hit scaffolds when the chemical space gets larger. In addition, the capability of this framework is limited by oracle functions.
Questions
- Molecules generated by building blocks and reactions are guaranteed to be highly likely synthesizable. Is it still necessary to evaluate empirical synthetic accessibility scores of these molecules? as these scores are generally inaccurate and they cannot tell much when a molecule already has synthesizability guarantee. - Can this framework be applied to bottom-up synthesis planning?
Rating
6
Confidence
3
Soundness
3
Presentation
3
Contribution
3
Limitations
See Weaknesses
Summary
This work proposes a workflow to synthesize molecules with reaction templates starting from some building blocks. Through this pipeline, the synthesizability of the generated molecules can be improved based on some experimental evidence of molecular drug design tasks.
Strengths
(1) This reviewer agrees with the importance of researching the synthesizability of generated molecules; (2) The presentation of the proposed approach is very clear. This reviewer can quickly understand the major idea of the whole workflow; (3) The idea of generating molecules with chemical reactions is very valuable since this reviewer also thinks the most important thing is generating synthesizable molecules.
Weaknesses
(1) The related work discussion in this work is insufficient. This reviewer just searches a bit on the web and find three highly related articles, which are "Bridging the gap between chemical reaction pretraining and conditional molecule generation with a unified model", "A generative model for molecule generation based on chemical reaction trees" and "Generating molecules via chemical reactions". This reviewer believes other relevant articles are not covered in this article. A more comprehensive and systematic related work section is required; (2) The proposed method has many limitations, including reliance on reaction templates and powerful pre-trained models. We state these limitations in the following section; (3) The evaluation of the proposed approach is not comprehensive enough. It does not include the conventional molecular generation benchmarks like novelty, validity, and diversity.
Questions
(1) This reviewer is concerned about the pre-trained oracle models. It seems that almost every step of the pipeline relies on a single pre-trained model. So how to derive these pre-trained models independently? (2) This reviewer is concerned about the ability to generate truly novel molecules. It seems the proposed approach starts with a selected set of fragments and deduces products through reaction templates. However, since reaction templates are extracted from known reactions, it seems nearly impossible to generate purely novel molecules through this pipeline. How do the authors address and evaluate this issue?
Rating
4
Confidence
4
Soundness
2
Presentation
3
Contribution
2
Limitations
(1) It seems the whole pipeline of RGFN heavily relies on many different pre-trained models. Each stage can affect the overall process drastically. (2) The proposed approach is based on reaction templates. The reaction templates must be updated frequently to cover more types of reactions. However, the template-based method has poor generalization to unseen reactions (new combinations of reactants).
Thanks to the authors for their detailed rebuttal and responding to each of my points. Particularly appreciate the additional experiments provided to address some of my/other reviewers' concerns. I have one minor follow up question regarding Q6, the answer to which I do not think I fully understand (partly also due to the response to Reviewer rpKJ's Question 2). I realize that RGFN might not necessarily generate the _best_ synthetic route to a proposed molecule, but I still do not understand why it does not generate _an_ explicit synthetic route. Are these not provided just by tracing back the sampling process for a product back to the initial building blocks? Some general comments on the other points made: * I appreciate that restricting to a smaller fragment library increases robustness (global response), although I am glad to see you recognise that the one used here is particularly small for many use cases and are taking steps to address this (and also support more complicated synthesis plans in future work). * Glad you will mention the related work initially overlooked. Pushing back though slightly on the importance of the template-based approach for reaction prediction used here, many of these other works often seem fairly agnostic to the reaction oracles used. * Thanks again for the new results (particularly with the quick turnaround), and also for discovering and fixing a mistake with the FGFN baseline. I still think it's a little weird that FGFN does not do particularly well on optimization (Q3), but thanks for the intuition regarding the fragment library/implementation provided in your rebuttal. Will begin discussing the paper with the other reviewers and (unless anything new comes up from this) increase my score to reflect you addressing several of my points.
Thank you for your comment. We would also like to take this opportunity to thank you again for a very thorough review, as that didn’t fit in the official answer. It is very appreciated and definitely helped us improve the paper. Answering the follow up question regarding Q6: Let us preface by saying that we suspect some of the ambiguity comes from different common understanding of the term “synthesis route” as used in ML and chemistry communities. In the ML community, the synthesis route is a sequence of reactions transforming sets of reactants into products. According to this definition, RGFN framework can output a synthesis route (albeit not necessarily the optimal one). However, in the answers and the paper we refer to the chemistry-based understanding of the term, elaborated on below. We apologize for the lack of clarity, we tried to be precise in chemical terminology, but recognize that given the audience we should clarify this, which we will do in the revised paper. To elaborate on the additional components needed for actual wet lab synthesis (which we refer to when we discuss a “synthesis route”): An explicit route is not generated, but rather the likely building blocks necessary to construct a molecule (and the knowledge of the reactions encoded) will be readily identifiable. This does not mean that an explicit synthetic route has been generated. A synthesis is more than just the building blocks and reactions used. 1. Firstly, consider a molecule ABCD constructed from four fragments (building blocks). A synthesis of such a molecule might proceed as A + B -> **AB** + C -> **ABC** + D -> **ABCD**. An alternative linear route might start with a coupling of B + C as the first step. Another alternative might employ a convergent synthesis, i.e., A + B -> **AB**, then C + D -> **CD**, and then **AB** + **CD** -> **ABCD**. There are other possibilities. Even if the same four building blocks are used for each these are not the same syntheses, and in practice they would show different degrees of success. A trained synthetic chemist would be able to suggest the best order of couplings. 2. In some cases “protection group” strategies or the use of surrogate functional groups and reactions may be needed or be more efficient. 3. In some cases alternative strategies to the synthesis might still be preferred. For example, in the convergent 3 step synthesis of **ABCD** shown above. If the final coupling is somehow incompatible (or not optimal) it might be necessary to employ a synthesis such as C + E -> **CE** and then do the coupling **AB** + **CE** -> **ABCE** followed by **ABCE** -> **ABCD**. Although this adds an extra reaction, if it avoids some incompatibility (or inefficiency) between the component **D** and coupling used, then this would be an acceptable solution (indeed issues like this are common – more often than not!). Again a trained synthetic chemist would be able to easily suggest such strategies (or alternatively software packages that explicitly design syntheses). 4. Careful choice of reaction conditions, external reagents, catalysts, etc. are also essential aspects of any synthesis. These are not established with RGFN. We hope that this answers the question. Also, regarding another remark: > Pushing back though slightly on the importance of the template-based approach for reaction prediction used here, many of these other works often seem fairly agnostic to the reaction oracles used. Could we please ask for a clarification on whether the Reviewer refers to the discussion in the shared rebuttal, Originality / Similar Works paragraph, specifically the reliance on pre-trained neural networks to predict synthetic trees? As we are not entirely sure to which point does that comment refer to.
Thanks for your reply: responding to your explanation and request for me to clarify my point
Thank you for your response and kind words! **Re Q6:** This is helpful thanks and answers my question! **Re my remark:** Happy to clarify this point. This was in response to the global "Author Rebuttal by Authors" posted above, namely under the section "Originality / Similar Works" and the statements: > We note that the majority (UniRXN, RXNGenerator, SynNet, ChemBO) rely on pre-trained neural networks to predict synthetic trees and therefore require the curation of large datasets of druglike molecules and generating ground-truth synthesis routes. ... . Moreover, while template-free methods like UniRXN, ChemBO, and MoleculeChef are capable of accurately predicting the products of reactions given reactants, they do not specify exactly the reaction used at each step - valuable information for chemists to prioritize easy-to-synthesize molecules out of a large pool of generated candidates. The particular form of the reaction oracle does not seem to be a key component of many current synthesis-based de novo design algorithms. To use methods which initially ran with template-free reaction oracles, such as ChemBO and MoleculeChef, with a template-based reaction oracle (that specified exactly the reaction used at each step) would be a very straightforward switch. Moreover, I don't believe that the requirement to curate large datasets is a particularly strong argument either. Yes, a model like SynNet uses approximately 200k synthesis plans for pre-training its NNs, but these synthesis plans are generated artificially and so this step seems on par with the 400k synthetic routes generated by GFlowNet in the process of its optimization. Likewise, ChemBO does not actually require pre-training on synthetic routes. Regarding the significance/originality, I was somewhat more convinced by the arguments you made in the rebuttal to my review above, suggesting work was needed to develop GFlowNets to operate in reaction space that I might have overlooked (bullet points: 1, 2, and 4, starting with "Handling multiple possible products...").
Thank you for your clarification! To address your points: yes, we agree that some of the existing methods (including the ones you mentioned) could potentially be extended to use e.g. our predefined set of high-yield chemical reactions and low-cost fragments. We would argue that in some sense, this makes our contribution of proposing a curated set of reactions and fragments more impactful, as it can benefit development of other methods. Moreover, even if it might seem “straightforward”, it required significant effort and chemical expertise to craft - so in a sense, it’s perhaps a slightly more interdisciplinary paper than a typical NeurIPS submission (but we would like to think that it makes it potentially more useful to propagate within the ML community). Regarding the dataset argument, we agree to some extent, but would like to point out that even such a large synthetic dataset would not guarantee generalization out of distribution. The ability to enforce hard domain constraints (by masking invalid actions) is one of the strengths of our method that makes it useful in this context. Finally, it's worth mentioning that the authors of ChemBO paper recognize this limitation: > While outputs of reactions are well known for simple cases, it is impossible to predict outcomes with complex molecules, and in some cases, the outputs may not even be deterministic. Fortunately however, there have been several advances in computational chemistry to predict outcomes of chemical reactions, which can be used in place of the oracle. In our work we use Rexgen [26]. It should be emphasized that since such predictors are not perfect, so in practice, ChemBO could end up recommending unsynthesizable molecules and/or incorrect synthesis recipes Thank you once again for an insightful discussion!
Reply to Authors
Thank you for providing a detailed rebuttal. Below are our reviewer's responses: (1) The reviewer expresses concern regarding the omission of related works, which may impact the novelty and significance of the proposed research. Merely including the omitted literature as references is insufficient. Further writing improvements are necessary to elucidate the major contributions of the proposed method compared to previous methods, thereby justifying its significance. (2) From a machine learning algorithm perspective, the technical contribution of the proposed method appears somewhat limited. The algorithm generates molecules using reaction templates, an approach widely adopted in template-based retrosynthesis analysis and forward reaction prediction. The reviewer does not identify significant algorithmic differences between the proposed method and template-based reaction modeling (both forward and backward). (3) The evaluations appear somewhat confusing and not comprehensive enough. Table 1 suggests that the proposed RGFN method does not achieve state-of-the-art performance in most tasks, causing the reviewer to question the method's superiority. Moreover, since the title emphasizes "molecular generation," typical empirical comparisons should include molecular generation benchmarks to demonstrate the basic VUN (Validity, Uniqueness, Novelty) of the proposed method. Building upon these fundamentals, an additional reasonable metric for evaluating synthesizability should be incorporated. Although the reviewer genuinely believes that molecular generations based on chemical reactions can be more reliable and synthesizable, the current evaluations are insufficient to demonstrate RetroGFN's superiority. In conclusion, the reviewer has decided to maintain their rating, and we kindly defer the decision to the AC.
We thank the Reviewer for answering our rebuttal. Regarding points 1 and 2, we again apologize for the omission of some mentioned papers and we are keen on improving the writing as per the Reviewer’s valuable suggestions. However, we believe that it does not fundamentally alter the presentation of our main novel contributions, which as discussed in the reply to the Reviewer 5soV are: - Handling multiple possible products of a given reaction, which results in a de facto non-deterministic environment. This is not an issue in FGFN, as operating on graphs allows us to specify the place of inserting a new fragment. We deal with this by introducing a product selection step (Eq. 5). - Since GFNs require computation of parent states and masking invalid actions, this required implementing efficient recursive decomposition of molecules into BBs and crafting specific SMARTS templates for reactions that would limit the possible number of parents. - Improving scalability by introducing fingerprint-based action embeddings for fragment selection. - Crafting a specific set of high-yield reactions and low-cost fragments that would enable fast and cheap synthesis experimentally, which has been a long-standing challenge in de novo small molecule discovery. Regarding point 3, we would like to emphasize that based on the (noisy) synthesizability metrics, RGFN does in fact achieve state-of-the-art performance in terms of synthesizability (and cost of synthesis, as illustrated in the Appendix), while preserving high performance in terms of mode discovery (higher than baseline methods other than FGFN). It’s this favorable balance that makes RGFN, in our opinion, an impactful approach, as easy synthesizability is the most important practical factor (unsynthesizable molecules with high property scores are not useful experimentally). As discussed in the paper, QED, molecular weight are included for completeness, but are secondary to AiZynthFinder scores, which in our opinions are the best approximation of synthesizability currently available. We will further clarify this in the updated manuscript with the Reviewer’s comments in mind. As discussed in the first answer, we would like to clarify that the metrics we utilize here are **chemically more rigorous than the typical VUN metrics**. VUN metrics are more suitable for methods such as 3D diffusion-based generative modeling where the model is trained on a dataset and inference can generate invalid molecules. All molecules generated by RGFN are valid by design (validity), RGFN is not trained on a dataset of molecules but on a reward function (i.e. novelty is not directly applicable, in the sense all of the molecules are “new”), and we use diversity which is a much stricter version of uniqueness. Typical graph-based generation methods, including most GFlowNet papers, use these more strict metrics as adopted here ([1-6]). We would argue that the ones used in our paper are more appropriate for illustrating a good trade-off between synthesizability and diversity of generated molecules. Regarding the comment that “additional reasonable metric for evaluating synthesizability should be incorporated”, we are eager to improve our manuscript and would kindly ask for the Reviewer to provide some specific suggestions for what other chemically rigorous metrics could be used. We were unable to identify realistic approaches to reliably do this - lack of good synthesizability evaluation metrics is, in fact, the main motivation behind RGFN. As pointed out by Reviewer rpKJ, showing the synthesizability of RGFN might not even be strictly necessary, as it guarantees it out-of-the-box by operating directly in the space of high-yield chemical reactions, and synthesizability metrics are inherently noisy. We hope you were convinced by our rebuttal to the other points in the first review (e.g. pre-trained models, usage of reaction templates). Please, let us know if you have any questions. Thank you once again for your detailed review and for considering our revisions. We are active in any further discussions and would really appreciate it if AC and SAC could take our explanations and clarification into consideration! [1] Zhang, Zaixi, et al. "Molecule generation for target protein binding with structural motifs." ICLR (2023). [2] Guo, Jeff, et al. "Link-INVENT: generative linker design with reinforcement learning." Digital Discovery (2023). [3] Zhu, Yiheng, et al. "Sample-efficient multi-objective molecular optimization with GFlowNets." NeurIPS (2024). [4] Korovina, Ksenia, et al. "ChemBO: Bayesian optimization of small organic molecules with synthesizable recommendations." PMLR (2020). [5] Nguyen, Dai Hai, and Koji Tsuda. "Generating reaction trees with cascaded variational autoencoders." The Journal of Chemical Physics (2022). [6] Swanson, Kyle, et al. "Generative AI for designing and validating easily synthesizable and structurally novel antibiotics." Nature Machine Intelligence (2024).
Requested additional experiments
We wanted to provide updated results for the experiments requested by Reviewers (added DRD2 task, and two additional baselines: RxnGenerator [1] and FGFN with the SA score included as a reward term). By now, all of the runs except RxnGenerator in the ClpP task were completed. Crucially, similar to SyntheMol, due to very large computational overhead we capped the run time of RxnGenerator at approximately 24 hours per run (which is above the total RGFN run time). For the final paper, we intend to actually further increase the run time of RxnGenerator, but based on the current results (smaller number of molecules visited and significantly lower average rewards), we believe any changes in the conclusions to be very unlikely. Since we are not allowed to provide any figures at this point, we instead show a table with two most relevant metrics (AiZynthFinder scores and the number of discovered modes). In general, the trends are comparable to the ones observed in the previous experiments: RGFN shows synthesizability scores comparable with other methods providing synthesizability guarantees (SyntheMol and RxnGenerator), illustrating the benefits of amortization of the GFlowNet framework. While in the sEH task AiZynth scores of RGFN are slightly lower, we suspect that it is mostly due to higher average weights of the generated molecules (since larger molecules are more difficult for AiZynthFinder to predict paths for). At the same time RGFN provides a significantly larger number of discovered modes (lower only than FGFN). Crucially, including SA score as a reward term for FGFN only marginally improves synthesizability (due to the unreliability of SA scores), at the same time decreasing the number of discovered modes. **Overall, this illustrates the usefulness of the RGFN framework, which has synthesizability guarantees similar to other synthesizability-focused methods, while producing significantly more diverse candidate molecules** (and does so using cheaper building blocks). | Task | Method | Mol. weight $\downarrow$ | AiZynth $\uparrow$ | Modes $\uparrow$ | |-------|--------------|--------------------------|--------------------|------------------| | DRD2 | GraphGA | 475.4 ± 53.2 | 0.41 | 664 | | | SyntheMol | 365.6 ± 54.3 | 0.66 | 728 | | | RxnGenerator | 418.1 ± 53.3 | **0.87** | 36 | | | FGFN | 386.5 ± 45.0 | 0.76 | 11396 | | | FGFN+SA | 381.1 ± 35.1 | 0.78 | 5903 | | | RGFN | 447.1 ± 45.7 | **0.87** | 6076 | | sEH | GraphGA | 528.6 ± 42.3 | 0.04 | 1327 | | | SyntheMol | 411.1 ± 66.7 | *0.80* | 2336 | | | RxnGenerator | 421.6 ± 103.4 | **0.82** | 5 | | | FGFN | 473.4 ± 58.9 | 0.14 | 21548 | | | FGFN+SA | 473.7 ± 62.2 | 0.27 | 5796 | | | RGFN | 495.2 ± 49.6 | 0.56 | 2875 | | Seno. | GraphGA | 485.7 ± 75.6 | 0.05 | 347 | | | SyntheMol | 441.4 ± 83.5 | 0.53 | 598 | | | RxnGenerator | 431.5 ± 100.9 | **0.65** | 12 | | | FGFN | 468.9 ± 47.7 | 0.02 | 44 | | | FGFN+SA | 451.8 ± 54.5 | 0.13 | 14 | | | RGFN | 558.7 ± 62.8 | *0.58* | 2276 | | ClpP | GraphGA | 521.0 ± 31.8 | 0.00 | 1571 | | | SyntheMol | 458.2 ± 60.7 | *0.56* | 1107 | | | RxnGenerator | - | - | - | | | FGFN | 548.6 ± 42.9 | 0.25 | 16960 | | | FGFN+SA | 509.2 ± 52.4 | 0.33 | 11959 | | | RGFN | 526.2 ± 37.6 | **0.65** | 2880 | [1] Nguyen, Dai Hai, and Koji Tsuda. "Generating reaction trees with cascaded variational autoencoders." The Journal of Chemical Physics 156.4 (2022).
Decision
Accept (poster)