liveBook · Manning

Acquisition function

As explained in Build AI Drug Discovery Pipelines

An acquisition function is a rule that scores candidate data points according to their expected usefulness for selecting the next samples in sequential learning.

An acquisition function scores unlabeled candidate molecules to decide which ones should be evaluated next. In active learning for drug discovery, it balances predicted promise, model uncertainty, and coverage of chemical space. section 9.2.5

Common selection signals include:

  • Greedy acquisition prioritizes molecules with the most favorable current model predictions, focusing evaluation on apparently promising regions. section 9.2.5
  • Uncertainty sampling selects molecules whose predictions vary most, targeting model confusion and potentially novel structural regions. section 9.2.5
  • Representativeness favors candidates that cover the input distribution, using diversity or density-aware selection to reduce over-specialization. section 9.2.5

Uncertainty can come from predictive variance, disagreement among ensemble models, Monte Carlo dropout, or proximity to a classification decision boundary. Combining uncertainty with representativeness supports a broader exploration–exploitation trade-off than relying on predictions alone. section 9.2.5 section 9.2.7

Using an acquisition function in progressive docking

Start by docking a small, diverse molecular set and training a surrogate model. At each iteration, use the acquisition function to select a batch from the remaining pool, dock those molecules, add their oracle scores to the training data, retrain, and update evaluation metrics. A run can track how many of the reference top 100 molecules are captured; one reported run found 73 of 100 after ten iterations while docking progressively larger batches. section 9.2.7

Listing 9.8 Greedy Acquisition and Uncertainty Sampling
def greedy_acquisition(model, X_pool, device, batch_size=1):
    predictions = model.predict(X_pool, device)
    best_indices = np.argsort(predictions)[:batch_size]
    return best_indices
 
def uncertainty_sampling(
    model, X_pool, device, batch_size=1, n_samples=100
):
    model.train()    #A
    all_predictions = np.zeros((n_samples, len(X_pool)))
    
    for i in range(n_samples):    #B
        inputs = torch.tensor(X_pool, dtype=torch.float32).to(device)
        
        with torch.no_grad():    #C
            outputs = model(inputs)            
        all_predictions[i, :] = outputs.cpu().numpy().flatten()
    
    uncertainties = np.std(all_predictions, axis=0)    #D
    best_indices = np.argsort(
        uncertainties
    )[::-1][:batch_size]    #E
    return best_indices
 
def select_next_molecule(
    model, X_pool, smiles_pool, device, best_score, batch_size=1, 
    acquisition_function="greedy", xi=0.01
):    #F
    if acquisition_function == "greedy":
        best_indices = greedy_acquisition(model, X_pool, device, batch_size)
    elif acquisition_function == "uncertainty":
        best_indices = uncertainty_sampling(model, X_pool, device)
    elif acquisition_function == "pi":
        best_indices = probability_of_improvement(
            model, X_pool, device, best_score, xi
        )
    elif acquisition_function == "ei":
        best_indices = expected_improvement(
            model, X_pool, device, best_score, xi
        )
    else:
        raise ValueError(f"Unknown acquisition function: {acquisition_function}")
 
    best_smiles = [smiles_pool[i] for i in best_indices]
    return best_indices, best_smiles

Inspect the greedy and uncertainty-sampling implementations: one ranks pool predictions, while the other estimates prediction spread across repeated stochastic passes. section 9.2.5

Listing 9.10 Active Learning Loop Implementation
def active_learning_loop(X_pool, smiles_pool, n_initial_samples,
                         n_iterations, budget_per_iteration, device,
                         reference_df=None, receptor_file=None,
                         top_reference_smiles=[],
                         initial_selection_method="random",
                         oracle=deepdock_oracle,
                         box=None, acquisition_function="greedy", xi=0.01,
                         log_dir="tensorboard_logs"):
    if device is None:
        device = torch.device(
            "cuda" if torch.cuda.is_available() else "cpu"
        )
    
    writer = initialize_tensorboard(log_dir)    #A
 
    initial_indices = initialize_samples(
        X_pool, initial_selection_method, n_initial_samples
    )    #B
    X_train = X_pool[initial_indices]
    smiles_train = [smiles_pool[i] for i in initial_indices]
 
    y_train = oracle(
        smiles_train, box=box, idx_list=initial_indices,
        reference_df=reference_df, receptor_file=receptor_file
    )    #C
 
    best_score = min(y_train)    #D
    top_molecules_found = calculate_top_molecules_captured(
        smiles_train, top_reference_smiles
    )
    writer.add_scalar(
        'Performance/TopMoleculesFound', top_molecules_found, 0
    )
    writer.add_scalar('Performance/BestScore', best_score, 0)
    print(f"Selected {len(X_train)} initial samples. "
          f"Found {top_molecules_found} top molecules.")
 
    # Remove initial samples from the pool
    mask = np.ones(len(X_pool), dtype=bool)    #E
    mask[initial_indices] = False
    X_pool = X_pool[mask]
    smiles_pool = [s for i, s in enumerate(smiles_pool) if mask[i]]
 
    model = DeepDockingModel(
        input_size=X_train.shape[1], hidden_size=512, output_size=1
    ).to(device)    #F
    train_history = train_deep_model(
        model, X_train, y_train, device, writer, global_step=0,
        epochs=10, batch_size=32
    )
 
    results = []
    for iteration in range(n_iterations):    #G
        print(f"\nStarting iteration {iteration + 1}/{n_iterations}")
        
        print(f"Selecting {budget_per_iteration} molecules "
              f"using {acquisition_function} acquisition...")
        start_time = time.time()
        best_indices, best_smiles = select_next_molecule(
            model, X_pool, smiles_pool, device, best_score, 
            batch_size=budget_per_iteration, 
            acquisition_function=acquisition_function, xi=xi, 
        )
        iteration_time = time.time() - start_time
 
        print("Docking selected molecules...")
        true_scores = oracle(
            best_smiles, box=box, idx_list=best_indices, 
            reference_df=reference_df, receptor_file=receptor_file
        )
        best_score = min(best_score, min(true_scores))
 
        selected_smiles_iter = best_smiles    #H
        selected_scores_iter = true_scores
 
        # Capture selected fingerprints before shrinking pool
        X_new = X_pool[best_indices].copy()
 
        # Update training data
        smiles_train.extend(selected_smiles_iter)
        y_train = np.concatenate([
            y_train, np.asarray(selected_scores_iter, dtype=float)
        ])
        X_train = np.vstack([X_train, X_new])
 
        # Update pool (remove selected molecules)
        mask = np.ones(len(X_pool), dtype=bool)    #I
        mask[best_indices] = False
        X_pool = X_pool[mask]
        smiles_pool = [s for i, s in enumerate(smiles_pool) if mask[i]]
 
        top_molecules_found = calculate_top_molecules_captured(
            smiles_train, top_reference_smiles
        )    #J
        writer.add_scalar(
            'Performance/TopMoleculesFound', top_molecules_found, iteration
        )
        writer.add_scalar('Performance/BestScore', best_score, iteration)
        print(f"Selected {len(smiles_train)} initial samples. "
              f"Found {top_molecules_found} top molecules.")
 
        results.append({
            'iteration': iteration + 1,
            'total_molecules': len(smiles_train),
            'top_molecules_found': top_molecules_found,
            'best_score': best_score,
            'time_per_iteration': iteration_time
        })
 
        print("Retraining surrogate model...")    #K
        train_deep_model(
            model, X_train, y_train, device, writer, iteration + 1
        )
 
        plot_chemical_space(
            writer, X_pool, X_train, iteration + 1
        )    #L
 
        if len(smiles_pool) == 0:
            print("Molecule pool is empty. "
                  "Terminating the active learning loop.")
            break
    writer.close()
    return pd.DataFrame(results)

Inspect the complete loop that initializes samples, selects batches, calls the docking oracle, retrains the model, and records progress. section 9.2.7

How Build AI Drug Discovery Pipelines covers it

How deep it goes
Explains uncertainty, representativeness, and loop integration with implementation listings, but defers detailed acquisition formulas.
Examples
Demonstrates greedy and uncertainty sampling, progressive docking, top-100 capture, chemical-space plots, and TensorBoard metrics.
What you can do after
Apply it via an active-learning loop that chooses molecular batches, obtains docking scores, retrains a model, and measures discovery progress.
How it connects
Connects active learning with surrogate models, uncertainty sampling, representativeness, virtual screening, and molecular docking.

Also explained in

Compare how 4 books explain acquisition function →

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.