artificial intelligence Archives - Pharmacelera | Pushing the limits of computational chemistry

Using Artificial Intelligence for faster Quantum Mechanical parametrization

Enric Herrero — Thu, 24 Oct 2024 09:51:56 +0000

By Carlos Cruz and Ana Caballero

The success of a ligand-based virtual screening campaign relies on their molecular descriptors, in this sense, Quantum Mechanics (QM) offer higher accuracy by capturing detailed electronic properties, the influence of 3D conformation, and key interactions that classical descriptors often overlook. Pharmacelera´s property molecular descriptors exploits self-consistent reaction ﬁelds methods to define hydrophobic topologies from atomic contributions.

Our unique descriptors are calculated using accurate QM methods, through the Recife Model 1 (RM1) parametrization of the Miertus Scrocco Tomassi (MST) model, which is known to be a reference method due to its good balance between accuracy and calculation time. However, QM calculations are still time-consuming, especially for huge chemical spaces. To handle this challenge, our team has developed a Machine Learning model for predicting atomic logP, to determine if exploring huge chemical spaces in a reduced amount of time is possible.

Our model includes physical descriptors (ex. topological, steric, and electrostatic descriptors), transferring information about the 3D environment of the atom to the model. The precise description of each atom gave us the possibility to develop and validate a model able to predict 3D atomic contributions to logP values with an R^2 >0.9 for any kind of neutral drug-like molecule 2.000 times faster than the calculations using the RM1 parametrization (see graphics (A) and (B))

Using this atomic description, we have accurately extended it to predict other atomic properties. For example, graph (C) shows the excellent results obtained for Mulliken Charges derived from Density Functional Theory calculations from the QMUGs library.

Interested in the application of QM methods to drug discovery? Pharmacelera software uses a unique 3D representation of molecules based on electrostatic, steric and hydrophobic interaction fields derived from semi-empirical QM calculations. Discover PharmScreen, exaScreen and PharmQSAR.

Need a customized solution for your drug discovery project? Contact our team to arrange a call and discuss your current challenges.

The post Using Artificial Intelligence for faster Quantum Mechanical parametrization appeared first on Pharmacelera | Pushing the limits of computational chemistry.

How do Neuronal Networks work?

Fernando Martín — Tue, 20 Sep 2022 15:02:00 +0000

By Enric Gibert

In one of my trips to Boston, I found a very good introduction to neural networks and deep learning. The book, whose title is “Deep Learning” from MIT Press being John Kelleher its author, is less than 300 pages long and it is a very pleasant reading during a flight across the Atlantic.

As we have explained in previous posts, Machine Learning is the field of Artificial Intelligence in which algorithms use data to automatically learn and find patterns and relationships. Deep learning, in particular, describes the set of algorithms and techniques in which a neural network with several hidden layers is employed as its core. Although deep learning can be used in unsupervised or reinforcement learning, most of the times it is applied in supervised environments. In supervised learning, a neural network or model is trained with input data (input values) and the expected outputs, and it is iteratively improved until convergence.

The book starts by explaining the basic concepts behind a neuron and a neural network. Although these are mathematical concepts, they are easy to follow and very well presented.

A neuron is a computation unit that performs 2 actions: it computes the weighted sum of its inputs, and it passes this computed value Z through an activation function. The following figure depicts a neuron.

The weighted sum of the input parameters is a straight linear mapping from inputs to outputs following the formula in the previous figure.

In one dimension (one input), this linear mapping can be plotted as a line as shown below. A plane represents the graphical relationship between two inputs and an output. The book uses these two types of neurons in the examples for simplicity, but in real cases, neurons will have more than two inputs. Although not representable in 3D, one can easily understand the extensions to these multi-dimensional cases.

An example of lines trying to match 4 datapoints is shown in the following figure, in which clearly line 3 is the one that best fits the datapoints (the error from the datapoints to the line function that describes them is smaller).

During the training process of a neural network, the weights of the neurons are randomly initialized and iteratively adjusted so that they converge to the expected output, as shown in the figure below. This figure assumes a neural network with one neuron and one input for simplicity. After several iterations, the model should converge to a line like the dark one.

As we have mentioned, once the weighted sum of the inputs is computed, the neuron applies an activation function. The book explains that threshold activation functions were very popular in the early days of neural network research, but they were systematically replaced by logistic functions. Nowadays, rectified linear are the most common activation functions, although this is still a research topic. The following figure shows these 3 types of activation functions.

The reason to use an activation function is to add a non-linear component to the model. In real life, the relationship between inputs and outputs (data correlations) is far more complex than a linear mapping. Even if a neural network may consist of multiple neurons disposed in different layers, the model would still be restricted to a multi-linear mapping. The activation functions of neurons provide this non-linear flexibility.

Once the book has explained the basics of a neuron, it explains several neural network configurations and their evolution.

A neural network is a machine learning model in which several neurons are connected and disposed in different layers. A deep neural network is a neural network with at least, 3 layers (nowadays, it is common to use neural networks with 10-100 layers). Since neural networks are formed by multiple ‘simple’ neurons, we can see that they apply a divide and conquer approach to learning. In the end, each layer / neuron solves a particular and small problem when looking for correlations between inputs and outputs. The following figure shows some neural network configurations.

The type and configuration of a neural network is a challenging task. The more complex it is (in number of layers, number of neurons, connections, activation function types, …) the more flexibility it has. However, the more complex it is, the higher chances that it might not converge, or it may take too long to do so. Human intervention is still an important aspect in the design and the implementation of a neural network, starting from the extraction, selection and organization of data to its design, training and deployment. Even though open-source packages such as Scikit Learn are extremely useful and valuable, human expertise still plays a key role.

The main challenge early research had with multiple layer neural networks was the distribution of the error among neurons in multiple layers. Although the book chapter that explains the gradient descent and backpropagation algorithms is the only chapter that requires more mathematical background, their concepts are easy to understand. The author even says that the book can be read without paying too much attention to this chapter if one is confused by the math.

The gradient descent algorithm is the method used to adjust the weights to iteratively converge to the best solution. Given the line example we used before (shown again in the figure below), the gradient descent algorithm iteratively decides how to adjust the ‘c’ parameter of the line equation (the ‘c’ parameter is called the intercept and it is treated as another input to the neuron with a weight of 1 and the ‘m’ parameter of the line equation (the slope).

The partial derivative with respect to each weight is used to update each individually. The idea is that if a weight contributed positively to the error, it will be decreased by a specific amount. If it contributed negatively, it will be increased. The specific value to decrease / increase a weight depends on whether it had a big / small contribution to the error. Note that since this is a multi-parameter optimization problem (even in the case of one input, since a line uses two values / weights, ‘c’ and ‘m’), finding a correct set of weight values is not a one-step process but an iterative one.

On the other hand, the backpropagation algorithm solves the problem of assigning or distributing the error (the blame) among the different layers and different neurons. It was not until this algorithm was proposed that neural networks with hidden layers were not used extensively.

The backpropagation algorithm works in two passes. In the first pass, the forward pass, the current neural network with the current weights is applied and all the weighted sums and activation outputs for each neuron are stored in memory. In the second pass, the backward pass, the error computed for each neuron in the output layer is back propagated or distributed to the previous hidden layer (the last hidden layer) using the different connections and weights among them. The algorithm proceeds by backpropagating these errors to previous hidden layers until the input layer is reached. At that point, each neuron in each layer has been assigned a part of the overall error (part of the blame) and the weights are adjusted by the gradient descent algorithm.

Although neural networks have been studied since the 1940s, its reinvigoration in the last two decades is mainly due to the availability of huge amounts of data (big data in the form of personal pictures, medical images, text in electronic format, digital voice recordings, videos, …) and the availability of specialized hardware. These two factors have boosted the research of more complex and deeper neural networks, leading to new applications and usages. Graphical Processing Units (GPUs) are the most predominant sort of specialized hardware, although there are other options such as Application-Specific Integrated Circuits (ASIC) and Field-Programmable Gate Arrays (FPGA). GPUs are particularly suited for vector and matrix multiplications and initially targeted game graphics. They have lately been applied to other fields that make heavy use of this type of calculations, such as machine learning and cryptocurrencies.

With this post, I hope that I have raised your interest in learning more about neural networks and that you will find the recommended book as a good starting point. You now have a new reading for your next trip across the Atlantic…

How Genetic Algorithms work?

Fernando Martín — Wed, 18 May 2022 07:29:21 +0000

Sometimes, the solution space in search and optimization problems cannot be expressed as a tree / graph of options (see previous AI post) or it cannot be easily traversed by heuristics or greedy algorithms. In those situations, we often use stochastic methods, those that heavily rely on a well described and rational random distribution. Genetic algorithms (or its broader concept of genetic programming) are one of such techniques.

Genetic algorithms are fascinating although they might look awkward at first. Do they really work? This is a question I have been asked many times. In fact, they do!

Genetic algorithms mimic the natural laws of evolution of living organisms that use genes as a way to code a solution to the problem of surviving in a specific environment. Such natural laws rely on natural selection and reproduction in a species to generate a population of best fit individuals.

For the sake of simplicity and clarity, we will use an example we described in our previous posts. Let’s imagine we want to design a molecule that best resembles a molecular reference by joining together 4 molecular building blocks from a pool of 65,536 building blocks. We will assume that any combination of building blocks is possible, that building blocks can be repeated, that the order of building blocks matters, and we will not take into consideration the chemical reactions required to link them.

Although the field has been widely studied and there are many aspects of genetic algorithms that can be solved differently (how to initialize the first generation or population, how to select individuals to cross over, how to mutate the individuals, how to measure the quality of the individuals, when to finish the search, …), we will use a few simple methods to understand the concept. In addition, most of these different methods depend on the particularity of the problem and they often need to be defined by human expertise.

In a genetic algorithm, an individual (or a solution to a problem) is digitally coded as a set of chromosomes, each chromosome representing a specific characteristic of the individual. In our particular case, each of the 4 building blocks of a potential molecule is a chromosome. Hence, a valid molecule (a valid solution to the problem of finding a molecule similar to a reference molecule) is coded as an array of 4 16-bit identifiers (we need 16 bits to code one of the 65,536 possible building blocks). Find below 3 examples of possible individuals (solutions to the problem).

We also need to define a fitness function, which describes how well the individual (the solution) satisfies the problem. In our case, we can use a Tanimoto-like metric to compare each molecule (each solution) to the reference molecule. We want to maximize this value.

Initially, the algorithm randomly generates a population of individuals (solutions). Let’s say a population of 10,000 randomly generated molecules (the identifiers of the building blocks are set to valid but arbitrary values). This population will become the first generation of the genetic algorithm and it will probably contain very poor individuals since their Tanimoto values will be very low (expected from a random population).

Next, the algorithm iterates over several generations in order to improve the individuals and to enhance the solution to the problem. At each iteration or generation, the algorithm selects individuals of the current population and it performs two different actions on them (cross over and mutation) to generate a similar size population (next generation) that will replace the previous one. The amount of iterations is very dependent on the problem. We can fix a number, we can define a convergence metric of the population or a combination of both (just in case the problem does not converge or it takes too long to do so). Let’s say we will iterate for 5,000 generations.

As commented, at each iteration, the algorithm selects pairs of two individuals, it crosses them over (reproduce) to generate a new individual, it might mutate it and it adds the new individual to the new generation (population). The iteration will be finished once the number of individuals in the next generation is equal to the number of individuals of the current generation.

In this select+cross+mutate cycle, the selection function prioritizes individuals from the current population that have a better fitness score. In this sense, it mimics natural selection by enabling good individuals (best fit) to have higher chances to generate off-spring (new solutions). The selection function also chooses poor individuals, although with less probability, to have a more diverse search space.

Crossing over (reproducing) two individuals means combining their chromosomes and generating a new individual (off-spring). Although several options exist, in our example, we will pick a random number of chromosomes from the first individual of the pair and the rest from the second. In the following figure, we show several potential offspring of two individuals.

Mutating an individual means randomly changing one or more of its chromosomes. Mutation is an action that needs to occur rarely but it will allow the algorithm to jump to a new part of the search space. In the following figure, we show several potential mutations of an individual.

At the end of all iterations, the best fit or the set of best fit individuals are the solutions that the algorithm has found.

The following pseudo-code depicts the behavior of the described algorithm. As a stochastic method, genetic algorithms are not deterministic in nature and will generate different solutions each time they are executed (there are mechanisms to make them “randomly deterministic” for debugging or reproducibility purposes).

Initialize random population P of X individuals
For a number of iterations do
  Create an empty new population P’
  Repeat until new population P’ has reached X individuals
    Select 2 individuals from current population P
    Cross over these 2 individuals to create a new individual
    Potentially mutate the chromosomes of the new individual with a low probability
    Add the new individual to the new population P’
  End repeat
  Make the new population P’ be the current population P
End for
Select the best individual/s as the pseudo-optimal solution/s

Graphically, the evolution of the population and the search for a solution would look like the following figures.

Initially, a randomly selected population will have individuals scattered around the search space as shown in the figure below, where the x-axis represents the solution space (each point being a different molecule or solution to the problem), the y-axis their Tanimoto value with respect to the reference (the value to maximize) and the circles the individuals of the population (for the sake of clarity we have just plotted 20 individuals, not 10,000).

Over time, since better individuals have more chances to be selected and crossed over, the population tends to the local / global maxima points, as shown in the figure below.

When the algorithm chooses to mutate an individual, it jumps to a new search space. If that new space is better than the current ones, this individual will have more probability to be selected and crossed over and the population will tend to move there. If the new space is worse, it does not have high chances to be selected and crossed over (low chances to survive). This is shown in the following picture for a single individual.

At the end, once the algorithm has iterated several times, the best individual or the best diverse individuals of the last population are the solutions found by the algorithm, as shown below. As commented before, the individuals of the last generation tend to be located near the local / global maxima points.

I hope this post has raised your interest in genetic algorithms and genetic programming and you will be eager to further read on this topic. Stay tuned for future Artificial Intelligence and Artificial Intelligence for Drug Discovery posts.

Want to learn more about how Pharmacelera can help you? Contact us and a member of our team will contact you to evaluate your project and how we can assist you with our technologies and services.

The post How Genetic Algorithms work? appeared first on Pharmacelera | Pushing the limits of computational chemistry.

DyNAbind and Pharmacelera engage in a research collaboration to apply Artificial Intelligence to DNA-Encoded Library screening

Fernando Martín — Fri, 01 Apr 2022 07:14:05 +0000

DyNAbind and Pharmacelera are happy to announce a joint scientific collaboration in the fields of DNA-Encoded Libraries (DEL) and Artificial Intelligence (AI) for drug discovery. DEL screening is perceived as one of the main sources of new chemical matter in forthcoming years as the technology enables testing millions of molecules in a single wet experiment, in contrast to traditional High-Throughput Screening (HTS) methodologies.

Some of the main challenges of DEL screenings are the management of noisy data as well as the conversion of binders into easily synthesizable or purchasable hits. Given the big amount of datapoints provided by DEL screening, AI and Ligand-Based Drug Discovery (LBDD) in-silico tools are attractive tools for overcoming these limitations. The conjunction of both companies’ technologies will enable pharmaceutical companies, biotech organizations and public research institutions to find novel chemical scaffolds with new Intellectual Property (IP) from a huge and unexplored chemical space.

“We are excited to begin this scientific collaboration with Pharmacelera and to assess the benefits of our complementary technologies for drug discovery“, says Michael Thompson, DyNAbind’s co-founder and CEO. “Pharmacelera’s accurate 3D molecular descriptors and expertise in AI can help in the post-processing of the data and in overcoming our main challenges”, he adds.

“DyNAbind is a premier organization in the area of DNA-Encoded Libraries, and we are very excited to kick-off a collaboration with them“, Enric Gibert, CEO of Pharmacelera explains. “DyNAbind’s DEL capabilities, which combine traditional small molecule approaches with fragment-based data, generate millions of useful and meaningful datapoints that our state-of-the-art LBDD tools and AI expertise can use to propose novel hits with larger chemical diversity”, he adds.

DyNAbind is a privately owned company focusing on novel DNA-Encoded Library approaches for drug discovery. The company combines small molecule and fragment-based approaches with unprecedented levels of library QC to offer more relevant medicinal chemistry start points in a highly drug-like space. A patented decoding system and powerful in-house informatics platform allows deep insight into the screening data for supporting either de novo drug design or optimization of existing ligands. Since foundation in 2017, DyNAbind has been based in Dresden, Germany and collaborates with pharmaceutical companies, biotechs and academic groups in the US, Europe and Asia.

Pharmacelera develops advanced computational tools for the discovery of novel hits using accurate Quantum-Mechanics (QM), Artificial Intelligence (AI) and High-Performance Computing (HPC). The company’s products PharmScreen and PharmQSAR use 3D molecular descriptors to mine an unexplored chemical space and to identify hits uncovered by traditional algorithms. Pharmacelera is a private company founded in 2015 and based in Barcelona, Spain. The company works with several big pharma and biotech organizations across Europe and the United States.

See press release at Dynabind.com

The post DyNAbind and Pharmacelera engage in a research collaboration to apply Artificial Intelligence to DNA-Encoded Library screening appeared first on Pharmacelera | Pushing the limits of computational chemistry.

Artificial Intelligence: tree search algorithms

Fernando Martín — Wed, 16 Mar 2022 09:33:52 +0000

As we explained in our previous post, Artificial Intelligence (AI) is more than Machine Learning (ML). Artificial Intelligence (AI) techniques include algorithms for finding optimal or pseudo-optimal solutions in complex problems, for example.

Several search problems can be described as a tree of options, in which each node of the tree is a partial or final solution to the problem and the branch below the node (if any), describes following options given that partial solution.

For instance, imagine we want to build a molecule by merging 4 building blocks from a pool of 1,000 blocks. For the sake of simplicity, let’s assume that building blocks can be combined in any form but two building blocks can only be combined in a single anchored point. The tree that describes the search space will have a root with an empty molecule (no building blocks) and a first level of nodes with width 1,000 (we can pick any building block as a starting point). A second level (depth) would consist of 1,000 nodes below each of the nodes in the first level: we can combine one building block with any of the 1,000 building blocks. And the same would happen for nodes in the 3^rd and 4^th levels (depths). Although this search tree has 4 depth levels given that we have described a constraint problem (4 building blocks), the search space is still enormous: 1,000^4 = 10^12.

As another example, the tree search space for a next chess game move is infinite. The root node of the tree describes the current situation of the pieces in the chess, each node below it describes a potential move of any of the existing pieces and so on for lower levels (depths). Each path from the root to any given node describes a series of potential moves (one white, one black). Since this is an unconstrained problem, search algorithms will limit the search space to an extent (e.g. a number of depths or next piece moves).

Note the importance of computing power to explore a large search space and to find better solutions in both cases in a reasonable amount of time.

Several algorithms exist for searching these tree spaces. These algorithms use a scoring function for each solution or partial solution to the problem (each tree node). In the case of molecules, it could be a Tanimoto-like score compared to a reference molecule. In the case of the chess game, it could be the difference between the number of existing pieces of the player taking the next move and the number of existing pieces of the opponent (evidently, this scoring is super simple, the one we used when we were kids).

Breadth-first search (BFS) algorithms explore first all the nodes of the current depth before exploring the nodes one depth lower. Depth-first search (DFS) algorithms, on the other hand, explore a given branch as deep as possible before backtracking up and following other branches. The following figure illustrates the search order to the molecular building blocks problem using BFS (in blue) and DFS (in green).

BFS algorithms require more memory than DFS algorithms, as the search space is explored in parallel and all options need to be kept in memory. DFS algorithms, on the other hand, are greedy algorithms that can get lost in a non-optimal branch if the search space is too big or infinite. Some DFS modifications tend to alleviate this problem by iteratively revisiting some of the top partial solutions and backtrack to other branches faster.

Several variants have been proposed to improve the time and memory requirements of these search algorithms. These variants mainly concentrate on two different aspects:

Branch prioritization: by measuring or predicting that specific branches can lead to better solutions, the algorithm can explore these branches first and reach an optimal or pseudo-optimal solution faster.
Branch pruning: by measuring or predicting that specific branches lead to poor solutions, the algorithm can prune those branches and skip exploring them.

A* algorithms, for example, are best-first search algorithms. The idea of A* is to measure what is the score of a given internal node of the search tree and explore the subbranch that can potentially maximize the scoring function first. At each internal node, the algorithm computes the scoring function of that partial solution and it predicts or measures how far all the subbranches are to the optimal or pseudo-optimal solution.

For example, in the case of the molecular subblocks, the algorithm can prioritize a branch that starts at depth 2 with a Tanimoto value of 0.5 of that partial solution than a branch that starts at depth 3 with a Tanimoto value of 0.1. This is so because it is easier to find a better solution in the former, as depicted in the following figure.

Branch and bound (BB or B&B) are also algorithms that prioritize some branches over others, but they also prune the search space by skipping specific branches that are computed to lead to suboptimal solutions. Such algorithms keep bounds or ranges of scoring values and they compute, at each internal node, if particular subbranches cannot lead to solutions that improve the best one found so far.

For simplicity, let’s assume that adding a building block can improve the current Tanimoto value of a partial solution in a range between 0 and 0.2. If the algorithm has already found a complete molecule of 4 building blocks that has a Tanimoto value of 0.95, it will not explore a subbranch at depth 2 if the Tanimoto value of that partial solution is 0.1. That partial solution can only be complemented by 2 building blocks and the best expected Tanimoto of any solution in that branch is 0.5 (the current 0.1 plus the maximum potential of +0.2 for each of the 2 final building blocks), as shown in the following figure.

The field of search algorithms, a fascinating component of Artificial Intelligence, is quite big and it has been widely studied. The basic algorithms described in this post date back from the 60s, 70s and 80s, with more modern variations in more recent years. I just wanted to provide a glimpse of some of the basic strategies. If interested, there are several books and papers around these topics.

Stay tuned for future post on other Artificial Intelligence posts.

The post Artificial Intelligence: tree search algorithms appeared first on Pharmacelera | Pushing the limits of computational chemistry.

Artificial Intelligence is NOT Machine Learning

Fernando Martín — Thu, 24 Feb 2022 05:51:38 +0000

By Enric Gibert – Feb. 24, 2022

Although the concepts of Artificial Intelligence (AI) and Machine Learning (ML) are used interchangeably, they are not the same.

Artificial Intelligence (AI) refers to the techniques and methods to demonstrate intelligence by machines, as opposed to the natural intelligence demonstrated by humans (supposedly ;-)). The field of AI was theorized in the 40s and 50s of last century. At a very high level, a machine would be considered intelligent if one interacted with it and could not differentiate whether machine replies were provided by another human sitting at the other side of the machine or by the machine itself. In other words, answers by a human and by a machine could not be distinguished.

AI is a very wide field that includes many areas such as expert systems, search algorithms, and Machine Learning (ML), among others.

Large knowledge-based databases such as expert systems consisting of a set of rules coded by humans is an example of AI. A toy expert system on vegetables can contain rules like “if round, green and size between 0.5 cm and 1.5 cm, then it is a pea”. However, one can imagine larger expert systems containing thousands of complex rules. Note that in this case, machines do not learn, as all knowledge is introduced (coded) by humans based on its expertise. Such systems seem intelligent, as they provide sound answers to specific questions. These expert systems can be equipped with inference algorithms to derive complex rules that are beyond the obvious human-coded rules. In this sense, inferencing is a first step towards machine learning.

Another AI area is search algorithms such as genetic algorithms, backtracking algorithms (in its depth-first, breadth-first or best-first versions such as A* search algorithms), or hill climbing. These algorithms try to find optimal solutions by exploring a wide range of potential candidate solutions. A chess game machine needs to decide what the best move is based on the current chessboard distribution and potential future moves by itself and by the opponent. The search space is humongous as the algorithm needs to evaluate and score many potential moves (“what if I move e4 – pawn to E4x -, the opponent moves e5 next – pawn E5 -, then I move NC3 – knight to C3 -, …” or “what if I move e4, the opponent moves e5 next, then I move BC4, …”) and chose the best one. The size of the search space depends on how deep (how many future movements) are considered. In this case, machines do not learn either, as they “simply” search for potential solutions that are built on-the-fly, but no knowledge or learning is retained or stored for future searches.

Machine Learning (ML) is the AI area in which machines automatically extract knowledge from data and experience that can be reused later to take decisions or propose predictions for new unseen situations. ML is being widely used in image recognition, speech recognition, web search algorithms, email filtering techniques, mating algorithms, … Regression analysis, artificial neural networks (and its more recent deep learning variants), support-vector machines and Bayesian networks, among others, are different ML techniques. In medical image recognition, for example, a deep neural network can be trained to early diagnose a particular neuro-degenerative disease using thousands of brain images. Once trained, the model can be used to predict whether new patients are developing that disease.

Evidently, sophisticated AI systems are hybrid systems that contain techniques from different areas. An algorithm for playing chess can contain human-typed rules (the most common chess openings, for instance), advanced backtracking search algorithms to decide the next move and a ML model to adapt the scoring function of the search algorithms based on previous actions by the opponent.

Since ML is the area of AI that is receiving more attention lately, these terms are often confused. But being ML a subset of AI, we can say that Artificial Intelligence is not Machine Learning, but Machine Learning is Artificial Intelligence.

Stay tuned for future short posts on Artificial Intelligence and Machine Learning.

The post Artificial Intelligence is NOT Machine Learning appeared first on Pharmacelera | Pushing the limits of computational chemistry.

Will Artificial Intelligence methods improve docking protocols?

Fernando Martín — Wed, 23 Sep 2020 07:51:55 +0000

By Lluis Campos – Sep. 23, 2020

Molecular Docking is a key tool in Structure Based Drug Discovery (SBDD), as it aims to determine the predominant binding mode of a ligand to a target protein. The process requires 1) a three-dimensional structure of the target protein and 2) the generation of thousands of poses for the ligand, among which the program will try to find the best fit. To do that, Molecular Docking programs use a Scoring Function (SF) [1].

SFs are, hence, mathematical tools used in SBDD to evaluate protein-ligand interactions. Using advanced physics and complex theoretical models is not the aim of SFs, as it would suppose an unaffordable computational cost. Rather than that, SFs are based on approximations, allowing a higher calculation effectivity, i.e., a better balance between accuracy and speed [2].

The function of a Scoring Function

The ideal SF should be able to accomplish three main tasks. The first one is to identify the correct binding orientation of each ligand to the active site of the protein when choosing among all generated poses. The second is the selection of potential lead compounds against a target protein by screening a ligand library. And the third one is the prediction of the absolute binding affinity between the ligand and the target. It is generally assumed that current SFs perform satisfyingly well at pose prediction, while virtual screening and specially binding affinity prediction remain as major challenges.

What types of Scoring Functions can I find?

Current classifications [2] group SFs in four different types. Force field/Physics-based SFs, Empirical SFs and Knowledge-based potentials are usually referred as “classical SFs”, while in recent years a new group has been defined as Descriptor-based or Machine Learning-based SFs.

Physics-based SFs were the first ones to be developed and they are based on the physical atomic interactions between target and ligand. These are usually divided in Van der Waals forces, computed as Lennard-Jones potentials, and electrostatic forces, calculated using Coulomb’s Law. Since this approximation neglects both entropic and desolvation contributions, very often physics-based SFs incorporate additional terms to account for them. Examples of this kind of SFs are GoldScore in the docking software GOLD and SFs in Autodock 3 and 4.

Empirical SFs are probably the most intuitive approach among the four groups. They compute binding affinity by adding up a set of weighted energy terms. These terms represent energetic factors for the binding, such as hydrophobic effects, hydrogen bonds, halogen bonds, steric clashes, etc. Multiple Linear Regression is used to infere the weights from a training set of protein-ligand complexes with known binding affinities. Again, some of these terms are often devoted to account for the entropic and desolvation effects. Examples of empirical SFs are ChemScore from GOLD and GlideScore SP in Schrödinger’s Glide.

Knowledge-based SFs are based on the inverse Boltzmann statistic principle. This principle assumes that, in a training set of protein-ligand complexes, the frequency of a pair of atoms at a specific distance is directly proportional to the contribution of this pair to the binding energy. Hence, frequencies of different pairs are converted into distance-dependent potentials, and the binding affinity can be then computed as the sum of all pairwise potentials present in the complex.

The new trend: Machine learning-based Scoring Functions

Machine Learning methods are being currently applied to every single data-based field and Computer-Aided Drug Discovery is not an exception. Computational chemists are taking advantage of the increasing amount of experimental data that is available nowadays to build models that can achieve better results than the more classical SFs above described. Far from what has been exposed for the latter, where functional forms differed in specific terms but had a common scaffold, a myriad of different functional forms can be obtained depending on the algorithm chosen; from Support Vector Machines and Random Forest to the more complex and opaque Deep Neural Networks.

Functional forms of Machine learning-based SFs, also called descriptor-based by some reviewers [2], are very similar compared to empirical SFs. However, there are three major reasons to group them in another category. First, whereas classical SFs have linear functional forms, descriptor-based SFs have different functional forms depending on the machine learning algorithm employed. Second, the number of terms tends to be extremely larger in descriptor-based SF; while it is rare to find empirical SFs with more than ten weighted terms, here hundreds of different descriptors can be exploited. And third, while individual terms in an empirical SF have an easily interpretable physical meaning, this is not necessarily the case for descriptor-based SFs, which might operate as a “black box”.

The greatest asset of this kind of SFs is also the major weakness of classical models, i.e., binding affinity prediction. The predictive power of a SF is often measured as the Pearson correlation coefficient (Rp) between the experimental binding energy and the one predicted by the model. Two conclusions can be extracted from the table below [3]. The first one is that in descriptor-based SF largely outperform the classical approaches, even the ones with better scores. And the second is that no new relevant classical SFs have been developed since the machine learning wave raised.

Furthermore, it has been demonstrated that the predictive capacity of descriptor-based SFs tends to be improved when larger training sets are provided. In this sense, many databases are now publicly available with loads of data about ligand-protein affinities. Probably the most popular among them is PDBbind, which is updated on an annual basis, and currently stores almost 13,000 carefully curated biomolecular complexes, from which around 10,000 are protein-ligand complexes.

The future of Scoring Functions

From the exposed above, it seems clear that machine learning is going to play an important role on the development of the state-of-the-art molecular docking software of the future. For now, many studies have taken profit of the fact that descriptor-based SFs are orthogonal to classical ones, and they are using them as rescoring functions to improve the results obtained by the latter. On the other hand, it is still unclear how the size and content of the training set can affect their performance, since in many cases it is strongly dependent on the target protein family.

Meanwhile, other possibilities for the development of new ways of assessing protein-ligand complementarity remain unexplored. To our knowledge, only one study has been published on the use of Molecular Interaction Fields (MIF) to predict protein-ligand interaction [4]. The results are promising and open the door for future work on the field. Pharmacelera’s hydrophobic MIFs have shown outstanding results applied to ligand-based virtual screening campaigns, but they are still to be used on structure-based approaches.

So, what do you think? Are the Scoring Functions of the future going to be fully machine-learning driven? Will they rather be a perfect complement for classic SFs? Or, alternatively, are we going to find better docking protocols without the need of these complex algorithms?

References

[1] J. Li, A. Fu, and L. Zhang, “An Overview of Scoring Functions Used for Protein–Ligand Interactions in Molecular Docking,” Interdiscip. Sci. Comput. Life Sci., vol. 11, no. 2, pp. 320–328, 2019.

[2] J. Liu and R. Wang, “Classification of current scoring functions,” J. Chem. Inf. Model., vol. 55, no. 3, pp. 475–482, 2015.

[3] H. Li, K. H. Sze, G. Lu, and P. J. Ballester, “Machine-learning scoring functions for structure-based drug lead optimization,” Wiley Interdiscip. Rev. Comput. Mol. Sci., no. November 2019, pp. 1–20, 2020.

[4] D. Hayakawa, N. Sawada, Y. Watanabe, and H. Gouda, “A molecular interaction field describing nonconventional intermolecular interactions and its application to protein–ligand interaction prediction,” J. Mol. Graph. Model., vol. 96, p. 107515, 2020.

The post Will Artificial Intelligence methods improve docking protocols? appeared first on Pharmacelera | Pushing the limits of computational chemistry.