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_smilesInspect 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



