liveBook · Manning

Progressive docking

As explained in Build AI Drug Discovery Pipelines

Deep docking is an active-learning approach that uses machine-learning models to predict binding affinities across large compound libraries and prioritize compounds for docking or synthesis.

Progressive docking uses active learning to screen enormous compound libraries without docking every molecule. A small, diverse set is docked first; its scores train a surrogate model that predicts docking-score proxies for the remaining compounds, allowing expensive evaluation to focus on promising candidates. section 9.0 section 9.2

A practical progressive-docking loop is:

  • Prepare the protein, define its binding box, load the compound pool, and dock an initial subset. section 9.2
  • Represent molecules with features such as Morgan fingerprints and train a surrogate model to predict docking scores. section 9.2.2
  • Select compounds using greedy ranking, uncertainty sampling, probability of improvement, or expected improvement. section 9.4
  • Dock selected compounds, add their results to the labeled data, and repeat until the screening budget is exhausted. section 9.0 section 9.4

Recovering high-scoring kinase compounds

For the VEGFR-2 kinase target (PDB ID: 4AG8), an active-learning run docked only a small fraction of the library yet recovered 73 of the top 100 molecules after 10 iterations. The approach can also deprioritize compounds from synthesis-on-demand libraries before they are synthesized. section 9.4 section 9.2

Listing 9.5 Deep Learning Surrogate Model for Binding Affinity Prediction
class DeepDockingModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size=1):
        super(DeepDockingModel, self).__init__()
        
        self.layers = nn.Sequential(    #A
            nn.Linear(input_size, hidden_size),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(hidden_size, hidden_size // 2),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(hidden_size // 2, output_size)
        )
 
    def forward(self, x):
        return self.layers(x)
 
    def predict(self, fingerprints, device):
        self.eval()    #B
        with torch.no_grad():    #C
            inputs = torch.tensor(
                np.atleast_2d(fingerprints), dtype=torch.float32
            ).to(device)    #D
            outputs = self(inputs)    #E
            return outputs.cpu().numpy().flatten()

Inspect the PyTorch surrogate model: a feedforward network uses ReLU activations, dropout, and Morgan fingerprints to predict binding-affinity scores. section 9.2.2

How Build AI Drug Discovery Pipelines covers it

How deep it goes
Explains the iterative workflow, surrogate architecture, sampling strategies, and low-data alternative while stopping short of detailed acquisition formulas.
Examples
Uses Enamine kinase hinge binders, EGFR docking workflows, and a VEGFR-2 experiment with PDB ID 4AG8.
What it assumes
Assumes basic molecular docking and machine-learning familiarity while introducing the active-learning rationale and surrogate-model workflow incrementally.
What you can do after
Build it from scratch with PyTorch and AutoDock Vina to prioritize compounds for docking or synthesis.
How it connects
Connects active learning, virtual screening, molecular fingerprints, neural networks, Gaussian processes, and synthesis-on-demand libraries.

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Build AI Drug Discovery Pipelines. The section links point to the parts of the book it draws on.