diff --git a/.github/workflows/draft-pdf.yaml b/.github/workflows/draft-pdf.yaml new file mode 100644 index 0000000..359df0c --- /dev/null +++ b/.github/workflows/draft-pdf.yaml @@ -0,0 +1,31 @@ +name: paper + +on: + push: + branches: + - "joss-paper" + paths: + - "paper.md" + +jobs: + paper: + runs-on: ubuntu-latest + name: Paper Draft + steps: + - name: Checkout + uses: actions/checkout@v2 + + - name: Build draft PDF + uses: openjournals/openjournals-draft-action@master + with: + journal: joss + paper-path: paper.md + + - name: Upload + uses: actions/upload-artifact@v1 + with: + name: paper + # This is the output path where Pandoc will write the compiled + # PDF. Note, this should be the same directory as the input + # paper.md + path: paper.pdf \ No newline at end of file diff --git a/figures/timing-dist.png b/figures/timing-dist.png new file mode 100644 index 0000000..1b8ea61 Binary files /dev/null and b/figures/timing-dist.png differ diff --git a/figures/timing-local.png b/figures/timing-local.png new file mode 100644 index 0000000..19b160f Binary files /dev/null and b/figures/timing-local.png differ diff --git a/paper.md b/paper.md new file mode 100644 index 0000000..3b12b71 --- /dev/null +++ b/paper.md @@ -0,0 +1,117 @@ +--- +title: 'pyscreener: A Python Wrapper for Computational Docking Software' +tags: + - Python + - drug discovery + - distributed computing + - molecular docking +authors: + - name: David E. Graff + orcid: 0000-0003-1250-3329 + affiliation: "1, 2" + - name: Connor W. Coley^[corresponding author] + orcid: 0000-0002-8271-8723 + affiliation: "2, 3" +affiliations: + - name: Department of Chemistry and Chemical Biology, Harvard University + index: 1 + - name: Department of Chemical Engineering, Massachusetts Institute of Technology + index: 2 + - name: Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology + index: 3 +date: XX November 2021 +bibliography: refs.bib +--- + +# Summary +`pyscreener` is a Python library that seeks to alleviate the challenges of large-scale structure-based design using computational docking. It provides a simple and uniform interface that is agnostic to the backend docking engine with which to calculate the docking score of a given molecule in a specified active site. Additionally, `pyscreener` features first-class support for task distribution, allowing users to seamlessly scale their code from a local, multi-core setup to a large, heterogeneous resource allocation. + +# Statement of Need +Computational docking is an important technique in structure-based drug design that enables the rapid approximation of binding affinity for a candidate ligand in a matter of CPU seconds. With the growing popularity of ultra-large ligand libraries, docking is increasingly used to sift through hundreds of millions of compounds to try to identify novel and potent binders for a variety of protein targets [@gorgulla_open-source_2020; @lyu_ultra-large_2019]. There are many choices of docking software, and certain software are better suited towards specific protein-ligand contexts (e.g., flexible protein side chains or sugar-like ligand molecules). Switching between these software is often not trivial as the input preparation, simulation, and output parsing pipelines differ between each software. + +In addition, many of these programs exist only as command-line applications and lack Python bindings. +This presents an additional challenge for their integration into molecular optimization workflows, such as reinforcement learning or genetic algorithms. +Molecular optimization objectives have largely been limited to benchmark tasks, such as penalized logP, QED, JNK3 or GSK3$\beta$ inhibitor classification [@li_multi-objective_2018], and others contained in the GuacaMol library [@brown_guacamol_2019]. These benchmarks are useful for comparing molecular design techniques, but they are not representative of true drug discovery tasks in terms of complexity; computational docking is at least one step in the right direction. + +While many molecular optimization techniques propose new molecules in the form of SMILES strings [@elton_deep_2019], most docking programs accept input in the form of molecular supply files with predefined 3D geometry (e.g., Mol2 or PDBQT format). Using the docking score of a molecule as a design objective thus requires an ad hoc implementation for which no standardized approach exists. +The `vina` library [@eberhardt_autodock_2021] is currently the only library capable of performing molecular docking within Python code, but it is limited to docking molecules using solely AutoDock Vina as the backend docking engine. +Moreover, the object model of the `vina` library accepts input ligands only as PDBQT files or strings and still does not address the need to quickly calculate the docking score of a molecule from its SMILES string. + +In our work on the MolPAL software [@graff_accelerating_2021], we required a library that is able to accept molecular inputs as SMILES strings and output their corresponding docking scores for a given receptor and docking box. Our use-case also called for docking large batches of molecules across large and distributed hardware setups. Lastly, we desired that our library be flexible with respect to the underlying docking engine, allowing us to use a variety of backend docking software (e.g., Vina [@trott_autodock_2010], Smina [@koes_lessons_2013], QVina [@alhossary_fast_2015], or DOCK6 [@allen_dock_2015]) with minimal changes to client code. To that end, we developed `pyscreener`, a Python library that is flexible with respect to both molecular input format and docking engine that transparently handles the distribution of docking simulations across large resource allocations. + +# Implementation and Performance +The primary design goals with `pyscreener` were to (1) provide a simple interface with which to calculate the docking score of an input small molecule and (2) transparently distribute the corresponding docking simulations across a large resource allocation. The object model of `pyscreener` relies on four classes: `CalculationData`, `CalculationMetadata`, `DockingRunner`, and `DockingVirtualScreen`. A docking simulation in `pyscreener` is fully described by a `CalculationData` and an associated `CalculationMetadata`. High-level information about the simulation that is common to all docking software (e.g., target protein, docking box, name of the ligand, the paths under which inputs and outputs will be stored) is stored in the `CalculationData` object. A `CalculationMetadata` contains the set of software-specific arguments for the simulation, such as `exhaustiveness` for the AutoDock Vina family of software or parameters for SPH file preparation for DOCK6. + +The `pyscreener` object model separates data from behavior by placing the responsibility of actually preparing, running, and parsing simulations inside the `DockingRunner` class. This stateless class defines methods to prepare simulation inputs, perform the simulation of the corresponding inputs, and parse the resulting output for a given `CalculationData` and `CalculationMetadata` pair. By placing this logic inside static methods rather than attaching them to the `CalculationData` object, `pyscreener` limits network data transfer overhead during task distribution. The separation also allows for the straightforward addition of new backend docking engines to `pyscreener`, as this entails only the specification of the corresponding `CalculationMetadata` and `DockingRunner` subclasses. + +`pyscreener` also contains the `DockingVirtualScreen` class, which contains a template `CalculationData` and `CalculationMetadata` with which to dock each input molecule, i.e., a virtual screening protocol. The class defines a `__call__()` method which takes SMILES strings or chemical files in any format supported by OpenBabel [@oboyle_open_2011] as input and distributes the corresponding docking simulations across the resources in the given hardware allocation, returning a docking score for each input molecule. + +![Wall-time of the computational docking of all 1,615 FDA-approved drugs against 5WIU using QVina2 over six CPU cores for a single-node setup with the specified number of CPU cores. (Left) calculated speedup. (Right) wall time in minutes. Bars reflect mean $\pm$ standard deviation over three runs.\label{fig:local}](figures/timing-local.png) + +To handle task distribution, `pyscreener` relies on the `ray` library [@moritz_ray_2018] for distributed computation. For multithreaded docking software, `pyscreener` allows a user to specify how many CPU cores to run each individual docking simulation over, running as many docking simulations in parallel as possible for a given number of total CPU cores in the `ray` cluster. To examine the scaling behavior of `pyscreener`, we docked all 1,615 FDA-approved drugs into the active site of the D4 dopamine receptor (PDB ID 5WIU [@wang_d4_2017]) with QVina2 running over 6 CPU cores. We tested both single node hardware setups, scaling the total number of CPU cores on one machine, and multi-node setups, scaling the total number of machines. In the single-node case, `pyscreener` exhibited essentially perfect scaling \autoref{fig:local} as we scaled the size of the `ray` cluster from 6 to 48 CPU cores running QVina over 6 CPU cores. + +![Wall-time of the computational docking of all 1,615 FDA-approved drugs against 5WIU using QVina2 over six CPU cores for setups using multiple 48-core nodes with the total number of specified CPU cores. (Left) calculated speedup. (Right) wall time in minutes. Bars reflect mean $\pm$ standard deviation over three runs.\label{fig:dist}](figures/timing-dist.png) + +In contrast, the multi-node setup exhibits less ideal scaling \autoref{fig:dist} with a measured speedup approximately 55% that of perfect scaling. We attribute this scaling behavior to hardware-dependent network communication overhead. Distributing a `sleep(5)` function allocated 6 CPU cores per task (to mimic a fairly quick docking simulation) in parallel over differing hardware setups +led to an approximate 2.5% increase in wall-time relative to the single-node setup each time the number of nodes in the setup was doubled while keeping the total number of CPU cores the same. Such a trend is consistent with network communication being detrimental to scaling behavior. This test also communicated the absolute minimum amount of data over the network, as there were no function arguments or return values. When communicating `CalculationData` objects (approximately 600 bytes in serialized form) over the network, as in `pyscreener`, the drop increased to 6% for each doubling of the total number of nodes. Minimizing the total size of `CalculationData` objects was therefore an explicit implementation goal. Future development will seek to further reduce network communication overhead costs to bring `pyscreener` scaling closer to ideal scaling. + +# Examples +To illustrate `pyscreener`, we consider docking benezene (SMILES string `"c1ccccc1"`) against 5WIU with a docking box centered at (-18.2, 14.4, -16.1) with x-, y-, and z-radii (15.4, 13.9, 14.5). We may perform this docking using AutoDock Vina over 6 CPU cores via `pyscreener` like so: +```python +import pyscreener as ps + +metadata = ps.build_metadata("vina") +virtual_screen = ps.virtual_screen( + "vina", + receptors=["5WIU.pdb"], + center=(-18.2, 14.4, -16.1), + size=(15.4, 13.9, 14.5), + metadata_template=metadata, + ncpu=6 +) +scores = virtual_screen("c1ccccc1") +print(scores) +# [-4.4] +``` + +Alternatively, we may dock many molecules by passing a `List` of SMILES strings to the `DockingVirtualScreen`: +```python +smis = [ + "c1ccccc1", + "O=C(Cc1ccccc1)NC1C(=O)N2C1SC(C2C(=O)O)(C)C", + "C=CCN1CCC23C4C(=O)CCC2(C1CC5=C3C(=C(C=C5)O)O4)O" +] +scores = virtual_screen(smis) +print(scores.shape) +# (3,) +``` + +By default, AutoDock Vina docks molecules using an `--exhaustiveness` value of 8, but we may specify a higher number in the `metadata`: +```python +metadata = ps.build_metadata("vina", dict(exhaustivness=32)) +``` +We may also utilize other docking engines in the AutoDock Vina family by specifying the `software` for Vina-type metadata. Here, we use the accelerated optimization routine of QVina for faster docking. Note that we also support `software` values of `"smina"` [@koes_lessons_2013] and `"psovina"` [@ng_psovina_2015] in addition to `"vina"` [@trott_autodock_2010] and `"qvina"` [@alhossary_fast_2015]. +```python +metadata = ps.build_metadata("vina", dict(software="qvina")) +``` + +It is also possible to dock molecules using DOCK6 [@allen_dock_2015] in `pyscreener`. To do this, we must first construct DOCK6 metadata and specify that we are creating a DOCK6 virtual screen (note that DOCK6 is not multithreaded and thus does not benefit from being assigned multiple CPU cores per task): +```python +metadata = ps.build_metadata("dock") +virtual_screen = ps.virtual_screen( + "dock", + receptors=["5WIU.pdb"], + center=(-18.2, 14.4, -16.1), + size=(15.4, 13.9, 14.5), + metadata_template=metadata +) +scores = virtual_screen("c1ccccc1") +print(scores) +# [-12.35] +``` + +# Acknowledgements + +The authors thank Keir Adams and Wenhao Gao for providing feedback on the preparation of this paper and the `pyscreener` code. The computations in this paper were run on the FASRC Cannon cluster supported by the FAS Division of Science Research Computing Group at Harvard University. The authors also acknowledge the MIT SuperCloud and Lincoln Laboratory Supercomputing Center for providing HPC and consultation resources that have contributed to the research results reported within this paper. This work was funded by the MIT-IBM Watson AI Lab. + +# References \ No newline at end of file diff --git a/refs.bib b/refs.bib new file mode 100644 index 0000000..7769afb --- /dev/null +++ b/refs.bib @@ -0,0 +1,275 @@ + +@article{eberhardt_autodock_2021, + title = {{AutoDock} {Vina} 1.2.0: {New} {Docking} {Methods}, {Expanded} {Force} {Field}, and {Python} {Bindings}}, + volume = {61}, + issn = {1549-9596}, + shorttitle = {{AutoDock} {Vina} 1.2.0}, + url = {https://doi.org/10.1021/acs.jcim.1c00203}, + doi = {10.1021/acs.jcim.1c00203}, + abstract = {AutoDock Vina is arguably one of the fastest and most widely used open-source programs for molecular docking. However, compared to other programs in the AutoDock Suite, it lacks support for modeling specific features such as macrocycles or explicit water molecules. Here, we describe the implementation of this functionality in AutoDock Vina 1.2.0. Additionally, AutoDock Vina 1.2.0 supports the AutoDock4.2 scoring function, simultaneous docking of multiple ligands, and a batch mode for docking a large number of ligands. Furthermore, we implemented Python bindings to facilitate scripting and the development of docking workflows. This work is an effort toward the unification of the features of the AutoDock4 and AutoDock Vina programs. The source code is available at https://github.com/ccsb-scripps/AutoDock-Vina.}, + number = {8}, + urldate = {2021-11-10}, + journal = {Journal of Chemical Information and Modeling}, + author = {Eberhardt, Jerome and Santos-Martins, Diogo and Tillack, Andreas F. and Forli, Stefano}, + month = aug, + year = {2021}, + note = {Publisher: American Chemical Society}, + pages = {3891--3898}, + file = {Full Text PDF:/Users/david/Zotero/storage/IKMEXENR/Eberhardt et al. - 2021 - AutoDock Vina 1.2.0 New Docking Methods, Expanded.pdf:application/pdf}, +} + +@article{koes_lessons_2013, + title = {Lessons {Learned} in {Empirical} {Scoring} with smina from the {CSAR} 2011 {Benchmarking} {Exercise}}, + volume = {53}, + issn = {1549-9596}, + url = {https://doi.org/10.1021/ci300604z}, + doi = {10.1021/ci300604z}, + abstract = {We describe a general methodology for designing an empirical scoring function and provide smina, a version of AutoDock Vina specially optimized to support high-throughput scoring and user-specified custom scoring functions. Using our general method, the unique capabilities of smina, a set of default interaction terms from AutoDock Vina, and the CSAR (Community Structure–Activity Resource) 2010 data set, we created a custom scoring function and evaluated it in the context of the CSAR 2011 benchmarking exercise. We find that our custom scoring function does a better job sampling low RMSD poses when crossdocking compared to the default AutoDock Vina scoring function. The design and application of our method and scoring function reveal several insights into possible improvements and the remaining challenges when scoring and ranking putative ligands.}, + number = {8}, + urldate = {2021-11-09}, + journal = {Journal of Chemical Information and Modeling}, + author = {Koes, David Ryan and Baumgartner, Matthew P. and Camacho, Carlos J.}, + month = aug, + year = {2013}, + note = {Publisher: American Chemical Society}, + pages = {1893--1904}, + file = {Full Text PDF:/Users/david/Zotero/storage/R2N4ZGBF/Koes et al. - 2013 - Lessons Learned in Empirical Scoring with smina fr.pdf:application/pdf;ACS Full Text Snapshot:/Users/david/Zotero/storage/KQU69ZQL/ci300604z.html:text/html}, +} + +@article{ng_psovina_2015, + title = {{PSOVina}: {The} hybrid particle swarm optimization algorithm for protein–ligand docking}, + volume = {13}, + issn = {0219-7200}, + shorttitle = {{PSOVina}}, + url = {https://www.worldscientific.com/doi/abs/10.1142/S0219720015410073}, + doi = {10.1142/S0219720015410073}, + abstract = {Protein–ligand docking is an essential step in modern drug discovery process. The challenge here is to accurately predict and efficiently optimize the position and orientation of ligands in the binding pocket of a target protein. In this paper, we present a new method called PSOVina which combined the particle swarm optimization (PSO) algorithm with the efficient Broyden–Fletcher–Goldfarb–Shannon (BFGS) local search method adopted in AutoDock Vina to tackle the conformational search problem in docking. Using a diverse data set of 201 protein–ligand complexes from the PDBbind database and a full set of ligands and decoys for four representative targets from the directory of useful decoys (DUD) virtual screening data set, we assessed the docking performance of PSOVina in comparison to the original Vina program. Our results showed that PSOVina achieves a remarkable execution time reduction of 51–60\% without compromising the prediction accuracies in the docking and virtual screening experiments. This improvement in time efficiency makes PSOVina a better choice of a docking tool in large-scale protein–ligand docking applications. Our work lays the foundation for the future development of swarm-based algorithms in molecular docking programs. PSOVina is freely available to non-commercial users at http://cbbio.cis.umac.mo.}, + number = {03}, + urldate = {2021-11-09}, + journal = {Journal of Bioinformatics and Computational Biology}, + author = {Ng, Marcus C. K. and Fong, Simon and Siu, Shirley W. I.}, + month = jun, + year = {2015}, + note = {Publisher: World Scientific Publishing Co.}, + keywords = {AutoDock, conformational search, drug design, flexible docking, Particle swarm optimization, protein–ligand docking}, + pages = {1541007}, + file = {Full Text PDF:/Users/david/Zotero/storage/W668EUMN/Ng et al. - 2015 - PSOVina The hybrid particle swarm optimization al.pdf:application/pdf}, +} + +@article{elton_deep_2019, + title = {Deep learning for molecular design—a review of the state of the art}, + volume = {4}, + issn = {2058-9689}, + url = {http://pubs.rsc.org/en/content/articlelanding/2019/me/c9me00039a}, + doi = {10.1039/C9ME00039A}, + abstract = {In the space of only a few years, deep generative modeling has revolutionized how we think of artificial creativity, yielding autonomous systems which produce original images, music, and text. Inspired by these successes, researchers are now applying deep generative modeling techniques to the generation and optimization of molecules—in our review we found 45 papers on the subject published in the past two years. These works point to a future where such systems will be used to generate lead molecules, greatly reducing resources spent downstream synthesizing and characterizing bad leads in the lab. In this review we survey the increasingly complex landscape of models and representation schemes that have been proposed. The four classes of techniques we describe are recursive neural networks, autoencoders, generative adversarial networks, and reinforcement learning. After first discussing some of the mathematical fundamentals of each technique, we draw high level connections and comparisons with other techniques and expose the pros and cons of each. Several important high level themes emerge as a result of this work, including the shift away from the SMILES string representation of molecules towards more sophisticated representations such as graph grammars and 3D representations, the importance of reward function design, the need for better standards for benchmarking and testing, and the benefits of adversarial training and reinforcement learning over maximum likelihood based training.}, + language = {en}, + number = {4}, + urldate = {2021-11-08}, + journal = {Molecular Systems Design \& Engineering}, + author = {Elton, Daniel C. and Boukouvalas, Zois and Fuge, Mark D. and Chung, Peter W.}, + month = aug, + year = {2019}, + note = {Publisher: The Royal Society of Chemistry}, + pages = {828--849}, + file = {Full Text PDF:/Users/david/Zotero/storage/IM3SLD65/Elton et al. - 2019 - Deep learning for molecular design—a review of the.pdf:application/pdf;Snapshot:/Users/david/Zotero/storage/Q6KAIJEW/c9me00039a.html:text/html}, +} + +@article{li_multi-objective_2018, + title = {Multi-objective de novo drug design with conditional graph generative model}, + volume = {10}, + issn = {1758-2946}, + url = {https://doi.org/10.1186/s13321-018-0287-6}, + doi = {10.1186/s13321-018-0287-6}, + abstract = {Recently, deep generative models have revealed itself as a promising way of performing de novo molecule design. However, previous research has focused mainly on generating SMILES strings instead of molecular graphs. Although available, current graph generative models are are often too general and computationally expensive. In this work, a new de novo molecular design framework is proposed based on a type of sequential graph generators that do not use atom level recurrent units. Compared with previous graph generative models, the proposed method is much more tuned for molecule generation and has been scaled up to cover significantly larger molecules in the ChEMBL database. It is shown that the graph-based model outperforms SMILES based models in a variety of metrics, especially in the rate of valid outputs. For the application of drug design tasks, conditional graph generative model is employed. This method offers highe flexibility and is suitable for generation based on multiple objectives. The results have demonstrated that this approach can be effectively applied to solve several drug design problems, including the generation of compounds containing a given scaffold, compounds with specific drug-likeness and synthetic accessibility requirements, as well as dual inhibitors against JNK3 and GSK-3β.}, + number = {1}, + urldate = {2021-11-08}, + journal = {Journal of Cheminformatics}, + author = {Li, Yibo and Zhang, Liangren and Liu, Zhenming}, + month = jul, + year = {2018}, + keywords = {De novo drug design, Deep learning, Graph generative model}, + pages = {33}, + file = {Full Text PDF:/Users/david/Zotero/storage/6BMHM42S/Li et al. - 2018 - Multi-objective de novo drug design with condition.pdf:application/pdf;Snapshot:/Users/david/Zotero/storage/6RJALWCU/s13321-018-0287-6.html:text/html}, +} + +@article{brown_guacamol_2019, + title = {{GuacaMol}: {Benchmarking} {Models} for de {Novo} {Molecular} {Design}}, + volume = {59}, + issn = {1549-9596}, + shorttitle = {{GuacaMol}}, + url = {https://doi.org/10.1021/acs.jcim.8b00839}, + doi = {10.1021/acs.jcim.8b00839}, + abstract = {De novo design seeks to generate molecules with required property profiles by virtual design-make-test cycles. With the emergence of deep learning and neural generative models in many application areas, models for molecular design based on neural networks appeared recently and show promising results. However, the new models have not been profiled on consistent tasks, and comparative studies to well-established algorithms have only seldom been performed. To standardize the assessment of both classical and neural models for de novo molecular design, we propose an evaluation framework, GuacaMol, based on a suite of standardized benchmarks. The benchmark tasks encompass measuring the fidelity of the models to reproduce the property distribution of the training sets, the ability to generate novel molecules, the exploration and exploitation of chemical space, and a variety of single and multiobjective optimization tasks. The benchmarking open-source Python code and a leaderboard can be found on https://benevolent.ai/guacamol.}, + number = {3}, + urldate = {2021-11-08}, + journal = {Journal of Chemical Information and Modeling}, + author = {Brown, Nathan and Fiscato, Marco and Segler, Marwin H.S. and Vaucher, Alain C.}, + month = mar, + year = {2019}, + note = {Publisher: American Chemical Society}, + pages = {1096--1108}, + file = {Full Text PDF:/Users/david/Zotero/storage/H56AMWBV/Brown et al. - 2019 - GuacaMol Benchmarking Models for de Novo Molecula.pdf:application/pdf;ACS Full Text Snapshot:/Users/david/Zotero/storage/YPKIYJ2M/acs.jcim.html:text/html}, +} + +@article{gorgulla_open-source_2020, + title = {An open-source drug discovery platform enables ultra-large virtual screens}, + volume = {580}, + copyright = {2020 The Author(s), under exclusive licence to Springer Nature Limited}, + issn = {1476-4687}, + url = {https://www.nature.com/articles/s41586-020-2117-z}, + doi = {10.1038/s41586-020-2117-z}, + abstract = {On average, an approved drug currently costs US\$2–3 billion and takes more than 10 years to develop1. In part, this is due to expensive and time-consuming wet-laboratory experiments, poor initial hit compounds and the high attrition rates in the (pre-)clinical phases. Structure-based virtual screening has the potential to mitigate these problems. With structure-based virtual screening, the quality of the hits improves with the number of compounds screened2. However, despite the fact that large databases of compounds exist, the ability to carry out large-scale structure-based virtual screening on computer clusters in an accessible, efficient and flexible manner has remained difficult. Here we describe VirtualFlow, a highly automated and versatile open-source platform with perfect scaling behaviour that is able to prepare and efficiently screen ultra-large libraries of compounds. VirtualFlow is able to use a variety of the most powerful docking programs. Using VirtualFlow, we prepared one of the largest and freely available ready-to-dock ligand libraries, with more than 1.4 billion commercially available molecules. To demonstrate the power of VirtualFlow, we screened more than 1 billion compounds and identified a set of structurally diverse molecules that bind to KEAP1 with submicromolar affinity. One of the lead inhibitors (iKeap1) engages KEAP1 with nanomolar affinity (dissociation constant (Kd) = 114 nM) and disrupts the interaction between KEAP1 and the transcription factor NRF2. This illustrates the potential of VirtualFlow to access vast regions of the chemical space and identify molecules that bind with high affinity to target proteins.}, + language = {en}, + number = {7805}, + urldate = {2020-09-11}, + journal = {Nature}, + author = {Gorgulla, Christoph and Boeszoermenyi, Andras and Wang, Zi-Fu and Fischer, Patrick D. and Coote, Paul W. and Padmanabha Das, Krishna M. and Malets, Yehor S. and Radchenko, Dmytro S. and Moroz, Yurii S. and Scott, David A. and Fackeldey, Konstantin and Hoffmann, Moritz and Iavniuk, Iryna and Wagner, Gerhard and Arthanari, Haribabu}, + month = apr, + year = {2020}, + note = {Number: 7805 +Publisher: Nature Publishing Group}, + pages = {663--668}, +} + +@article{lyu_ultra-large_2019, + title = {Ultra-large library docking for discovering new chemotypes}, + volume = {566}, + copyright = {2019 The Author(s), under exclusive licence to Springer Nature Limited}, + issn = {1476-4687}, + url = {http://www.nature.com/articles/s41586-019-0917-9}, + doi = {10.1038/s41586-019-0917-9}, + abstract = {Despite intense interest in expanding chemical space, libraries containing hundreds-of-millions to billions of diverse molecules have remained inaccessible. Here we investigate structure-based docking of 170 million make-on-demand compounds from 130 well-characterized reactions. The resulting library is diverse, representing over 10.7 million scaffolds that are otherwise unavailable. For each compound in the library, docking against AmpC β-lactamase (AmpC) and the D4 dopamine receptor were simulated. From the top-ranking molecules, 44 and 549 compounds were synthesized and tested for interactions with AmpC and the D4 dopamine receptor, respectively. We found a phenolate inhibitor of AmpC, which revealed a group of inhibitors without known precedent. This molecule was optimized to 77 nM, which places it among the most potent non-covalent AmpC inhibitors known. Crystal structures of this and other AmpC inhibitors confirmed the docking predictions. Against the D4 dopamine receptor, hit rates fell almost monotonically with docking score, and a hit-rate versus score curve predicted that the library contained 453,000 ligands for the D4 dopamine receptor. Of 81 new chemotypes discovered, 30 showed submicromolar activity, including a 180-pM subtype-selective agonist of the D4 dopamine receptor.}, + language = {en}, + number = {7743}, + urldate = {2020-09-11}, + journal = {Nature}, + author = {Lyu, Jiankun and Wang, Sheng and Balius, Trent E. and Singh, Isha and Levit, Anat and Moroz, Yurii S. and O’Meara, Matthew J. and Che, Tao and Algaa, Enkhjargal and Tolmachova, Kateryna and Tolmachev, Andrey A. and Shoichet, Brian K. and Roth, Bryan L. and Irwin, John J.}, + month = feb, + year = {2019}, + pages = {224--229}, + file = {Full Text PDF:/Users/david/Zotero/storage/6VERWE3G/Lyu et al. - 2019 - Ultra-large library docking for discovering new ch.pdf:application/pdf;Snapshot:/Users/david/Zotero/storage/XZ2LTNHR/s41586-019-0917-9.html:text/html}, +} + +@article{allen_dock_2015, + title = {{DOCK} 6: {Impact} of new features and current docking performance}, + volume = {36}, + copyright = {© 2015 Wiley Periodicals, Inc.}, + issn = {1096-987X}, + shorttitle = {{DOCK} 6}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/jcc.23905}, + doi = {10.1002/jcc.23905}, + abstract = {This manuscript presents the latest algorithmic and methodological developments to the structure-based design program DOCK 6.7 focused on an updated internal energy function, new anchor selection control, enhanced minimization options, a footprint similarity scoring function, a symmetry-corrected root-mean-square deviation algorithm, a database filter, and docking forensic tools. An important strategy during development involved use of three orthogonal metrics for assessment and validation: pose reproduction over a large database of 1043 protein-ligand complexes (SB2012 test set), cross-docking to 24 drug-target protein families, and database enrichment using large active and decoy datasets (Directory of Useful Decoys [DUD]-E test set) for five important proteins including HIV protease and IGF-1R. Relative to earlier versions, a key outcome of the work is a significant increase in pose reproduction success in going from DOCK 4.0.2 (51.4\%) → 5.4 (65.2\%) → 6.7 (73.3\%) as a result of significant decreases in failure arising from both sampling 24.1\% → 13.6\% → 9.1\% and scoring 24.4\% → 21.1\% → 17.5\%. Companion cross-docking and enrichment studies with the new version highlight other strengths and remaining areas for improvement, especially for systems containing metal ions. The source code for DOCK 6.7 is available for download and free for academic users at http://dock.compbio.ucsf.edu/. © 2015 Wiley Periodicals, Inc.}, + language = {en}, + number = {15}, + urldate = {2020-09-14}, + journal = {Journal of Computational Chemistry}, + author = {Allen, William J. and Balius, Trent E. and Mukherjee, Sudipto and Brozell, Scott R. and Moustakas, Demetri T. and Lang, P. Therese and Case, David A. and Kuntz, Irwin D. and Rizzo, Robert C.}, + year = {2015}, + keywords = {cross-docking, DOCK, docking, enrichment, ligand flexibility, pose reproduction, virtual screening}, + pages = {1132--1156}, + file = {Snapshot:/Users/david/Zotero/storage/A8KZF9V7/jcc.html:text/html;Accepted Version:/Users/david/Zotero/storage/V3YUJFCQ/Allen et al. - 2015 - DOCK 6 Impact of new features and current docking.pdf:application/pdf}, +} + +@article{trott_autodock_2010, + title = {{AutoDock} {Vina}: {Improving} the speed and accuracy of docking with a new scoring function, efficient optimization, and multithreading}, + volume = {31}, + copyright = {Copyright © 2009 Wiley Periodicals, Inc.}, + issn = {1096-987X}, + shorttitle = {{AutoDock} {Vina}}, + url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/jcc.21334}, + doi = {10.1002/jcc.21334}, + abstract = {AutoDock Vina, a new program for molecular docking and virtual screening, is presented. AutoDock Vina achieves an approximately two orders of magnitude speed-up compared with the molecular docking software previously developed in our lab (AutoDock 4), while also significantly improving the accuracy of the binding mode predictions, judging by our tests on the training set used in AutoDock 4 development. Further speed-up is achieved from parallelism, by using multithreading on multicore machines. AutoDock Vina automatically calculates the grid maps and clusters the results in a way transparent to the user. © 2009 Wiley Periodicals, Inc. J Comput Chem 2010}, + language = {en}, + number = {2}, + urldate = {2020-09-14}, + journal = {Journal of Computational Chemistry}, + author = {Trott, Oleg and Olson, Arthur J.}, + year = {2010}, + keywords = {AutoDock, computer-aided drug design, molecular docking, multithreading, scoring function, virtual screening}, + pages = {455--461}, + file = {Snapshot:/Users/david/Zotero/storage/VAWDVUUG/jcc.html:text/html;Accepted Version:/Users/david/Zotero/storage/LRKF5EJA/Trott and Olson - 2010 - AutoDock Vina Improving the speed and accuracy of.pdf:application/pdf}, +} + +@article{moritz_ray_2018, + title = {Ray: {A} {Distributed} {Framework} for {Emerging} {AI} {Applications}}, + shorttitle = {Ray}, + url = {http://arxiv.org/abs/1712.05889}, + abstract = {The next generation of AI applications will continuously interact with the environment and learn from these interactions. These applications impose new and demanding systems requirements, both in terms of performance and flexibility. In this paper, we consider these requirements and present Ray---a distributed system to address them. Ray implements a unified interface that can express both task-parallel and actor-based computations, supported by a single dynamic execution engine. To meet the performance requirements, Ray employs a distributed scheduler and a distributed and fault-tolerant store to manage the system's control state. In our experiments, we demonstrate scaling beyond 1.8 million tasks per second and better performance than existing specialized systems for several challenging reinforcement learning applications.}, + urldate = {2021-03-24}, + journal = {arXiv:1712.05889 [cs, stat]}, + author = {Moritz, Philipp and Nishihara, Robert and Wang, Stephanie and Tumanov, Alexey and Liaw, Richard and Liang, Eric and Elibol, Melih and Yang, Zongheng and Paul, William and Jordan, Michael I. and Stoica, Ion}, + month = sep, + year = {2018}, + keywords = {Computer Science - Artificial Intelligence, Computer Science - Distributed, Parallel, and Cluster Computing, Computer Science - Machine Learning, Statistics - Machine Learning}, + file = {arXiv Fulltext PDF:/Users/david/Zotero/storage/MUDSKW4N/Moritz et al. - 2018 - Ray A Distributed Framework for Emerging AI Appli.pdf:application/pdf;arXiv.org Snapshot:/Users/david/Zotero/storage/F8NQ9TJQ/1712.html:text/html}, +} + +@article{graff_accelerating_2021, + title = {Accelerating high-throughput virtual screening through molecular pool-based active learning}, + volume = {12}, + issn = {2041-6539}, + url = {http://pubs.rsc.org/en/content/articlelanding/2021/sc/d0sc06805e}, + doi = {10.1039/D0SC06805E}, + abstract = {Structure-based virtual screening is an important tool in early stage drug discovery that scores the interactions between a target protein and candidate ligands. As virtual libraries continue to grow (in excess of 108 molecules), so too do the resources necessary to conduct exhaustive virtual screening campaigns on these libraries. However, Bayesian optimization techniques, previously employed in other scientific discovery problems, can aid in their exploration: a surrogate structure–property relationship model trained on the predicted affinities of a subset of the library can be applied to the remaining library members, allowing the least promising compounds to be excluded from evaluation. In this study, we explore the application of these techniques to computational docking datasets and assess the impact of surrogate model architecture, acquisition function, and acquisition batch size on optimization performance. We observe significant reductions in computational costs; for example, using a directed-message passing neural network we can identify 94.8\% or 89.3\% of the top-50 000 ligands in a 100M member library after testing only 2.4\% of candidate ligands using an upper confidence bound or greedy acquisition strategy, respectively. Such model-guided searches mitigate the increasing computational costs of screening increasingly large virtual libraries and can accelerate high-throughput virtual screening campaigns with applications beyond docking.}, + language = {en}, + number = {22}, + urldate = {2021-06-16}, + journal = {Chemical Science}, + author = {Graff, David E. and Shakhnovich, Eugene I. and Coley, Connor W.}, + month = jun, + year = {2021}, + pages = {7866--7881}, + file = {Full Text PDF:/Users/david/Zotero/storage/NRBJP9SZ/Graff et al. - 2021 - Accelerating high-throughput virtual screening thr.pdf:application/pdf;Snapshot:/Users/david/Zotero/storage/YB8874YD/D0SC06805E.html:text/html}, +} + +@article{alhossary_fast_2015, + title = {Fast, accurate, and reliable molecular docking with {QuickVina} 2}, + volume = {31}, + issn = {1367-4803}, + url = {https://doi.org/10.1093/bioinformatics/btv082}, + doi = {10.1093/bioinformatics/btv082}, + abstract = {Motivation: The need for efficient molecular docking tools for high-throughput screening is growing alongside the rapid growth of drug-fragment databases. AutoDock Vina (‘Vina’) is a widely used docking tool with parallelization for speed. QuickVina (‘QVina 1’) then further enhanced the speed via a heuristics, requiring high exhaustiveness. With low exhaustiveness, its accuracy was compromised. We present in this article the latest version of QuickVina (‘QVina 2’) that inherits both the speed of QVina 1 and the reliability of the original Vina.Results: We tested the efficacy of QVina 2 on the core set of PDBbind 2014. With the default exhaustiveness level of Vina (i.e. 8), a maximum of 20.49-fold and an average of 2.30-fold acceleration with a correlation coefficient of 0.967 for the first mode and 0.911 for the sum of all modes were attained over the original Vina. A tendency for higher acceleration with increased number of rotatable bonds as the design variables was observed. On the accuracy, Vina wins over QVina 2 on 30\% of the data with average energy difference of only 0.58 kcal/mol. On the same dataset, GOLD produced RMSD smaller than 2 Å on 56.9\% of the data while QVina 2 attained 63.1\%.Availability and implementation: The C++ source code of QVina 2 is available at (www.qvina.org).Contact:aalhossary@pmail.ntu.edu.sgSupplementary information:Supplementary data are available at Bioinformatics online.}, + number = {13}, + urldate = {2021-11-08}, + journal = {Bioinformatics}, + author = {Alhossary, Amr and Handoko, Stephanus Daniel and Mu, Yuguang and Kwoh, Chee-Keong}, + month = jul, + year = {2015}, + pages = {2214--2216}, + file = {Full Text PDF:/Users/david/Zotero/storage/4I5GJSPW/Alhossary et al. - 2015 - Fast, accurate, and reliable molecular docking wit.pdf:application/pdf;Snapshot:/Users/david/Zotero/storage/C28MUHDH/195750.html:text/html}, +} + +@article{oboyle_open_2011, + title = {Open {Babel}: {An} open chemical toolbox}, + volume = {3}, + issn = {1758-2946}, + shorttitle = {Open {Babel}}, + url = {https://doi.org/10.1186/1758-2946-3-33}, + doi = {10.1186/1758-2946-3-33}, + abstract = {A frequent problem in computational modeling is the interconversion of chemical structures between different formats. While standard interchange formats exist (for example, Chemical Markup Language) and de facto standards have arisen (for example, SMILES format), the need to interconvert formats is a continuing problem due to the multitude of different application areas for chemistry data, differences in the data stored by different formats (0D versus 3D, for example), and competition between software along with a lack of vendor-neutral formats.}, + number = {1}, + urldate = {2021-11-08}, + journal = {Journal of Cheminformatics}, + author = {O'Boyle, Noel M. and Banck, Michael and James, Craig A. and Morley, Chris and Vandermeersch, Tim and Hutchison, Geoffrey R.}, + month = oct, + year = {2011}, + keywords = {Atom Type, Bond Connectivity, Canonical Code, Chemical Markup Language, File Format}, + pages = {33}, + file = {Full Text PDF:/Users/david/Zotero/storage/ETMRNLRT/O'Boyle et al. - 2011 - Open Babel An open chemical toolbox.pdf:application/pdf}, +} + +@article{wang_d4_2017, + title = {D4 dopamine receptor high-resolution structures enable the discovery of selective agonists}, + volume = {358}, + url = {http://www.science.org/doi/10.1126/science.aan5468}, + doi = {10.1126/science.aan5468}, + number = {6361}, + urldate = {2021-11-08}, + journal = {Science}, + author = {Wang, Sheng and Wacker, Daniel and Levit, Anat and Che, Tao and Betz, Robin M. and McCorvy, John D. and Venkatakrishnan, A. J. and Huang, Xi-Ping and Dror, Ron O. and Shoichet, Brian K. and Roth, Bryan L.}, + month = oct, + year = {2017}, + pages = {381--386}, + file = {Full Text PDF:/Users/david/Zotero/storage/U2VB9XRA/Wang et al. - 2017 - D4 dopamine receptor high-resolution structures en.pdf:application/pdf}, +}