OpenBind Zika Virus Blind Challenge Tutorial: sample notebook

A worked notebook for OpenBind Zika Virus Blind Challenge Tutorial, with 22 code cells and the output each one printed. On Scigantic it opens in a hosted JupyterLab with the dataset already mounted, so nothing is downloaded first.

Provider
OpenADMET, OpenBind Consortium
License
Apache 2.0
Size
428 objects, 68.3 MB
Format
CSV, Parquet, PDB format, FASTA (in sampled files)
Stored at
Amazon S3, s3://scigantic-openbind-challenge-1 (us-east-1)
Access
Free and public. No account with the data provider is needed.

The notebook

Start here. Click the grey cell below and press Shift+Enter. It reads one of the 400 blinded compounds out of the mounted archive and draws it. Change COMPOUND to any id from blind_challenge_001 to blind_challenge_400 and run it again.

Everything after it is already run, so you can scroll the whole tutorial first and come back.

# Start here: one of the 400 blinded compounds, straight from the mounted archive.
import os
from pathlib import Path

import pandas as pd
from rdkit import Chem
from rdkit.Chem import Descriptors

COMPOUND = "blind_challenge_001"   # change me: blind_challenge_001 .. blind_challenge_400

ARCHIVE = Path(os.environ.get("SCIGANTIC_MOUNT_PATH") or Path.home() / "archive")
blinded = pd.read_csv(ARCHIVE / "compounds" / "openbind-blind-challenge-1-TEST-BLINDED.csv")
row = blinded.set_index("Molecule_Name").loc[COMPOUND]
mol = Chem.MolFromSmiles(row["SMILES"])

print(f"{len(blinded)} blinded compounds in this challenge; showing {COMPOUND}")
print(f"  SMILES      {row['SMILES']}")
print(f"  heavy atoms {mol.GetNumHeavyAtoms()}   MW {Descriptors.MolWt(mol):.1f}   LogP {Descriptors.MolLogP(mol):.2f}")
print("Every one of these was soaked into Zika NS2B-NS3 protease crystals and the")
print("structure withheld. The tutorial below predicts one and formats it for submission.")
mol

Workflow for Structure Prediction on the OpenBind Blind Challenge 1

This notebook demonstrates a lightweight, CPU-friendly tutorial workflow. The goal is to show how to:

Because running a full structure prediction pipeline is difficult to do in a lightweight Jupyter workflow, we focus on data preparation, quality checks, and submission-ready formatting.

from pathlib import Path
import zipfile

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from tqdm.auto import tqdm
from rdkit import Chem
from rdkit.Chem import Draw, Descriptors, rdMolDescriptors
from rdkit.Chem.Scaffolds import MurckoScaffold 

from matplotlib.offsetbox import OffsetImage, AnnotationBbox
tqdm.pandas()
sns.set_style("whitegrid")
sns.set_context("notebook")
# Optional packages used in later cells
try:
    import nglview as nv
except Exception:
    nv = None

try:
    import biotite.structure.io as strucio
except Exception:
    strucio = None
# Added for the mounted copy: the tutorial's paths assume you are in notebooks/ and
# that you can write next to them. ~/archive is read-only, so reads resolve against
# the mounted tutorial and writes go to your home directory.
import os

ARCHIVE = Path(os.environ.get("SCIGANTIC_MOUNT_PATH") or Path.home() / "archive")
TUTORIAL = ARCHIVE / "tutorial"
WORK = Path.home() / "openbind-challenge"
WORK.mkdir(exist_ok=True)

print("tutorial :", TUTORIAL)
print("compounds:", ARCHIVE / "compounds")
print("writing  :", WORK)

Output:

tutorial : /mnt/archive/tutorial
compounds: /mnt/archive/compounds
writing  : /home/jovyan/openbind-challenge

1. Loading the data

Load the blinded ligand list directly from Hugging Face.

test_structure = pd.read_csv(
    ARCHIVE / "compounds" / "openbind-blind-challenge-1-TEST-BLINDED.csv"
)
test_structure.head()

Output:

         Molecule_Name                                 SMILES
0  blind_challenge_001  O=C(Nc1ccc2c(c1)CNC2)c1cccc2cn[nH]c12
1  blind_challenge_002     O=C(Nc1ccc2c(c1)CNC2)c1cccn2nccc12
2  blind_challenge_003  Cn1ccc2cccc(C(=O)Nc3ccc4c(c3)CNC4)c21
3  blind_challenge_004  O=C(Nc1ccc2c(c1)CNC2)c1nccc2cc[nH]c12
4  blind_challenge_005  O=C(Nc1ccc2c(c1)CNC2)c1cccc2[nH]ccc12

2. Preparing the data for prediction

The main input is the ligand SMILES list so preprocessing is minimal:

required_cols = ["Molecule_Name", "SMILES"]
missing_cols = [col for col in required_cols if col not in test_structure.columns]
if missing_cols:
    raise ValueError(f"Missing required columns in test_structure: {missing_cols}")

structure_df = test_structure[required_cols].copy().rename(columns={"Molecule_Name": "id", "SMILES": "SMILES"})
structure_df["mol"] = structure_df["SMILES"].apply(Chem.MolFromSmiles)

invalid_smiles = structure_df["mol"].isna().sum()
print(f"Total ligands: {len(structure_df)}")
print(f"Invalid SMILES: {invalid_smiles}")
structure_df.head()

Output:

Total ligands: 400
Invalid SMILES: 0
                    id                                 SMILES  \
0  blind_challenge_001  O=C(Nc1ccc2c(c1)CNC2)c1cccc2cn[nH]c12   
1  blind_challenge_002     O=C(Nc1ccc2c(c1)CNC2)c1cccn2nccc12   
2  blind_challenge_003  Cn1ccc2cccc(C(=O)Nc3ccc4c(c3)CNC4)c21   
3  blind_challenge_004  O=C(Nc1ccc2c(c1)CNC2)c1nccc2cc[nH]c12   
4  blind_challenge_005  O=C(Nc1ccc2c(c1)CNC2)c1cccc2[nH]ccc12   

                                             mol  
0  <rdkit.Chem.rdchem.Mol object at 0x114e6b220>  
1  <rdkit.Chem.rdchem.Mol object at 0x114e6b290>  
2  <rdkit.Chem.rdchem.Mol object at 0x114e6b300>  
3  <rdkit.Chem.rdchem.Mol object at 0x114e6b370>  
4  <rdkit.Chem.rdchem.Mol object at 0x114e6b3e0>
Load the NS2B-NS3 protein sequence from a FASTA file

For this tutorial, we include a local FASTA file the Zika protein sequence from a local FASTA file stored in inputs/NS2B-NS3_protein_sequence.fasta.

This FASTA contains a monomeric NS2B-NS3 sequence. No additional chain information is needed for the challenge submission.

fasta_path = TUTORIAL / "inputs" / "NS2B-NS3_protein_sequence.fasta"

if not fasta_path.exists():
    raise FileNotFoundError(f"Missing FASTA file: {fasta_path}")

fasta_text = fasta_path.read_text().strip()

# This file holds TWO records, NS3 then NS2B, from the entity records of PDB entry
# 29HN. Joining every line after the first header into one string, as the original
# cell did, leaves the second header sitting inside the sequence.
fasta_chains = {}
for block in fasta_text.split(">"):
    if not block.strip():
        continue
    header, *sequence_lines = block.splitlines()
    chain = header.split("|")[1].replace("Chain ", "").strip()
    fasta_chains[chain] = "".join(line.strip() for line in sequence_lines)

ns2b_sequence = fasta_chains["A"]   # cofactor
ns3_sequence = fasta_chains["B"]    # protease domain

for chain, sequence in sorted(fasta_chains.items()):
    print(f"chain {chain}: {len(sequence)} aa  {sequence[:30]}...")
display(fasta_text)

Output:

chain A: 46 aa  SMGKSVDMYIERAGDITWEKDAEVTGNSPR...
chain B: 168 aa  MKEVKKGETTDGVYRVMTRRLLGSTQVGVG...

3. Exploratory data analysis

Before moving to structure prediction, we first inspect the blinded ligand set.

In this section we will:

eda_df = structure_df.dropna(subset=["mol"]).copy()
print(f"Valid molecules: {len(eda_df)} / {len(structure_df)}")

if eda_df.empty:
    raise ValueError("No valid molecules available. Check SMILES parsing in step 2.")

sample_n = min(24, len(eda_df))
sample_mols = eda_df["mol"].head(sample_n).tolist()
sample_legends = eda_df["id"].head(sample_n).tolist()

img = Draw.MolsToGridImage(
    sample_mols,
    molsPerRow=6,
    subImgSize=(220, 180),
    legends=sample_legends,
)
img

Output:

Valid molecules: 400 / 400

To analyze structural diversity, we compute Bemis–Murcko scaffolds for each ligand and count unique scaffold chemotypes.

eda_df["murcko_mol"] = eda_df["mol"].apply(
    lambda molecule: MurckoScaffold.GetScaffoldForMol(molecule) if molecule is not None else None
)
eda_df["murcko_smiles"] = eda_df["murcko_mol"].apply(
    lambda scaffold: Chem.MolToSmiles(scaffold) if scaffold is not None else ""
)

# Keep non-empty scaffolds for counting
murcko_series = eda_df.loc[eda_df["murcko_smiles"] != "", "murcko_smiles"]
num_unique_scaffolds = murcko_series.nunique()
print(f"Number of unique Murcko scaffolds: {num_unique_scaffolds}")

Output:

Number of unique Murcko scaffolds: 222

Now we visualize the most frequent scaffolds. The bar chart shows scaffold counts, and scaffold images are overlaid below each bar for quick structural interpretation.

def add_scaffold_images(axis, smiles_list, image_size=(120, 120), zoom=0.5, y_offset=-60):
    for index, smiles in enumerate(smiles_list):
        if not smiles:
            continue

        molecule = Chem.MolFromSmiles(smiles)
        if molecule is None:
            continue

        scaffold_image = Draw.MolToImage(molecule, size=image_size)
        image_box = OffsetImage(scaffold_image, zoom=zoom)
        annotation = AnnotationBbox(
            image_box,
            (index, 0),
            xybox=(0, y_offset),
            xycoords=("data", "data"),
            boxcoords="offset points",
            frameon=False,
        )
        axis.add_artist(annotation)
top_n = 10
scaffold_counts = murcko_series.value_counts().head(top_n)
scaffolds_df = scaffold_counts.rename_axis("smiles").reset_index(name="count")

fig, axis = plt.subplots(figsize=(12, 6))
sns.barplot(
    data=scaffolds_df,
    x=scaffolds_df.index,
    y="count",
    color="steelblue",
    ax=axis,
)

add_scaffold_images(axis, scaffolds_df["smiles"])

axis.set_ylabel("Count")
axis.set_xlabel(f"Top {top_n} Murcko Scaffolds")
axis.set_title(f"Most Frequent Scaffolds (N molecules = {len(eda_df)})")
axis.set_xticklabels([])
axis.set_ylim(0, scaffolds_df["count"].max() * 1.25)
axis.grid(axis="y", linestyle="--", alpha=0.6)
fig.subplots_adjust(bottom=0.22)
plt.tight_layout()

4. Generating a protein–ligand structure

For this tutorial, we avoid running a heavy structure-prediction model and instead use a pre-generated Boltz-2 co-folded prediction.

To generate a protein–ligand structure with Boltz-2, you need a YAML input file containing the protein sequence and ligand SMILES. In the cells below, we create that YAML directly from:

We then preview the generated YAML and inspect the pre-generated protein–ligand structure in inputs/blind_challenge_001_model_0.cif.

boltz_cif = TUTORIAL / "inputs" / "blind_challenge_001_model_0.cif"
boltz_yaml = WORK / "blind_challenge_001.yaml"

example_ligand_id = "blind_challenge_001"
example_rows = structure_df.loc[structure_df["id"] == example_ligand_id, ["id", "SMILES"]]
if example_rows.empty:
    raise ValueError(f"Could not find ligand '{example_ligand_id}' in structure_df")

example_smiles = example_rows.iloc[0]["SMILES"]
example_yaml = f"""version: 1
sequences:
- protein: {{id: A, sequence: {ns2b_sequence}}}
- protein: {{id: B, sequence: {ns3_sequence}}}
- ligand: {{id: C, smiles: {example_smiles}}}
properties:
- affinity: {{binder: C}}
"""

boltz_yaml.write_text(example_yaml)
print(f"Wrote YAML file: {boltz_yaml}")
print("\nYAML preview:")
print("-" * 80)
print(example_yaml)

Output:

Wrote YAML file: /home/jovyan/openbind-challenge/blind_challenge_001.yaml

YAML preview:
--------------------------------------------------------------------------------
version: 1
sequences:
- protein: {id: A, sequence: SMGKSVDMYIERAGDITWEKDAEVTGNSPRLDVALDESGDFSLVEE}
- protein: {id: B, sequence: MKEVKKGETTDGVYRVMTRRLLGSTQVGVGVMQEGVFHTMWHVTKGAALRSGEGRLDPYWGDVKQDLVSYCGPWKLDAAWDGLSEVQLLAVPPGERAKNIQTLPGIFKTKDGDIGAVALDYPAGTSGSPILDKCGRVIGLYGNGVVIKNGSYVSAITQGKREEETPVE}
- ligand: {id: C, smiles: O=C(Nc1ccc2c(c1)CNC2)c1cccc2cn[nH]c12}
properties:
- affinity: {binder: C}

In this example, the generated YAML also includes an affinity prediction property for the ligand. This field is optional and is not evaluated in the challenge, so you can remove it if you only want structure prediction.

The cell below draws the predicted complex as a still, so you can see where the ligand sits without running anything. The NGLView cell after it is the interactive version: run it to turn the model yourself. It needs the nglview package.

# A still of the predicted complex, so this section shows something without
# the 3D widget below. Two projections, because one flat view of a pocket
# can look like contact that is not there.
import matplotlib.pyplot as plt

cif = TUTORIAL / "inputs" / "blind_challenge_001_model_0.cif"

chains, ligand, cols, in_loop = {}, [], [], False
with open(cif) as handle:
    for line in handle:
        s = line.strip()
        if s.startswith("_atom_site."):
            cols.append(s.split(".")[1]); in_loop = True; continue
        if in_loop and cols:
            if s.startswith("#") or not s:
                break
            f = s.split()
            if len(f) < len(cols):
                continue
            rec = dict(zip(cols, f))
            try:
                xyz = (float(rec["Cartn_x"]), float(rec["Cartn_y"]), float(rec["Cartn_z"]))
            except (KeyError, ValueError):
                continue
            if rec.get("group_PDB") == "HETATM":
                if rec.get("type_symbol") != "H":
                    ligand.append(xyz)
            elif rec.get("label_atom_id") == "CA":
                chains.setdefault(rec.get("label_asym_id", "?"), []).append(xyz)

sizes = ", ".join(f"chain {c} {len(v)} res" for c, v in sorted(chains.items()))
print(f"{cif.name}: {sizes}, ligand {len(ligand)} heavy atoms")

# NS2B is the short cofactor strand, NS3 the protease domain it wraps.
colours = ["#6f8fa6", "#c9a227", "#8fa6b8"]
fig, axes = plt.subplots(1, 2, figsize=(9.5, 4.3))
for ax, (i, j) in zip(axes, [(0, 1), (0, 2)]):
    for n, (cid, atoms) in enumerate(sorted(chains.items(), key=lambda kv: -len(kv[1]))):
        ax.plot([a[i] for a in atoms], [a[j] for a in atoms], "-",
                color=colours[n % len(colours)], lw=1.4, zorder=1,
                label=f"chain {cid} ({len(atoms)} res)")
    ax.scatter([l[i] for l in ligand], [l[j] for l in ligand], s=46,
               color="#1f77b4", edgecolor="white", lw=0.6, zorder=3,
               label="blind_challenge_001")
    ax.set_xlabel(f"{'xyz'[i]} (A)"); ax.set_ylabel(f"{'xyz'[j]} (A)")
    ax.set_aspect("equal", adjustable="datalim")
    ax.spines[["top", "right"]].set_visible(False)
axes[0].legend(loc="upper left", fontsize=8, frameon=False)
fig.suptitle("Boltz-2 predicted complex, CA trace with the predicted ligand pose", fontsize=11)
fig.tight_layout()
plt.show()

Output:

blind_challenge_001_model_0.cif: chain A 39 res, chain B 156 res, ligand 21 heavy atoms
if nv is not None:
    print(str(boltz_cif))
    v = nv.show_file(str(boltz_cif))
    v.clear_representations()
    v.add_representation("cartoon", selection="protein", color="lightgreen")
    v.add_representation("ball+stick", selection="hetero")
    display(v)
else:
    print("nglview is not installed — skipping structure visualisation. Install with: pip install nglview")

5. Prepare submission and validate

Submission requirements for this track:

Boltz-2 CIF outputs may label the ligand as LIG1. The helper below converts a CIF or PDB to a correctly named PDB file with the residue name normalised.

def rewrite_ligand_resname_pdb(
    input_structure: Path,
    output_pdb: Path,
    old_resname: str = "LIG1",
    new_resname: str = "LIG",
):
    """Read a structure file and write a PDB with ligand residue name normalized."""
    if strucio is None:
        raise ImportError("biotite is required for residue renaming. Install with: pip install biotite")

    # Generic load handles CIF/PDB based on extension
    stack = strucio.load_structure(str(input_structure))

    if hasattr(stack, "res_name"):
        mask = stack.res_name == old_resname
        if np.any(mask):
            stack.res_name[mask] = new_resname

    strucio.save_structure(str(output_pdb), stack)
    return output_pdb
# Example: batch-convert a directory of Boltz-2 CIF outputs to submission-ready PDBs.
# Each output file is named {id}.pdb to match the required submission format.
# Adjust cif_dir to point to your own prediction directory.

cif_dir = TUTORIAL / "inputs"  # replace with your Boltz-2 output directory
output_dir = WORK / "my_structure_submission"
output_dir.mkdir(parents=True, exist_ok=True)

for cif_file in sorted(cif_dir.glob("*_model_0.cif")):
    ligand_id = cif_file.stem.removesuffix("_model_0")
    out_pdb = output_dir / f"{ligand_id}.pdb"
    try:
        rewrite_ligand_resname_pdb(cif_file, out_pdb, old_resname="LIG1", new_resname="LIG")
        print(f"Converted {cif_file.name} -> {out_pdb.name}")
    except Exception as exc:
        print(f"Failed {cif_file.name}: {exc}")

Output:

Converted blind_challenge_001_model_0.cif -> blind_challenge_001.pdb

Once all 400 PDB files are ready in a directory (one {id}.pdb per ligand), use the cell below to package them into a zip and validate before uploading.

Here is code you can use to validate and zip all structure submissions

The example here uses outputs/example_structure_submission, which contains a pre-generated Boltz-2 prediction for each ligand in the blinded set that we have prepared for you. Replace submission_dir with output_dir from the cell above to validate your own predictions.

import sys

project_root = TUTORIAL
if str(project_root) not in sys.path:
    sys.path.append(str(project_root))

from validation.structure_validation import validate_structure_submission

# Point this to your directory of 400 PDB files
submission_dir = TUTORIAL / "outputs" / "example_structure_submission"
zip_path = WORK / "example_structure_submission.zip"

pdb_files = sorted(submission_dir.glob("*.pdb"))
with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
    for pdb in pdb_files:
        zf.write(pdb, arcname=pdb.name)

print(f"Created zip archive: {zip_path} ({len(pdb_files)} files)")

expected_smiles_dict = dict(zip(structure_df["id"], structure_df["SMILES"]))

is_valid, validation_errors = validate_structure_submission(
    zip_path,
    expected_ids=set(structure_df["id"]),
    expected_ligand_smiles=expected_smiles_dict,
    require_lig_resname=True,
)

if is_valid:
    print("✅ Submission is valid — ready to upload.")
else:
    print("❌ Submission is invalid:")
    for msg in validation_errors:
        print(f"  - {msg}")

Output:

Created zip archive: /home/jovyan/openbind-challenge/example_structure_submission.zip (400 files)
✅ Submission is valid — ready to upload.

What the PDB already holds for this chemotype

One section that is not in the tutorial repository. The compounds are blinded, but the chemistry is not new: the largest series here is an isoindoline benzamide, which the ASAP Discovery Consortium worked on, and the wwPDB Chemical Component Dictionary already describes every small molecule that has been modelled into a deposited structure.

scigantic_wwpdb searches that dictionary by name and pulls components by id, over the network, with no download and nothing on the mount. Two questions worth asking before you predict anything: is any blinded compound already a deposited component, and if not, are there close relatives whose experimental coordinates could serve as a pose template?

import scigantic_wwpdb as wwpdb

# The dominant Murcko scaffold in the blinded set: an isoindoline benzamide.
scaffold = Chem.MolFromSmiles("O=C(Nc1ccc2c(c1)CNC2)c1ccccc1")
carrying = sum(
    1 for molecule in eda_df["mol"] if molecule is not None and molecule.HasSubstructMatch(scaffold)
)
print(f"{carrying} of {len(eda_df)} blinded compounds are built on that scaffold")

# Name search, then one batched metadata call, then an actual substructure test:
# component names are not reliable enough to trust on their own.
candidate_ids = []
for query in ("isoindoline carboxamide", "indazole carboxamide", "isoindoline"):
    candidate_ids += wwpdb.search(query, limit=50)
candidate_ids = list(dict.fromkeys(candidate_ids))

related = [
    summary
    for summary in wwpdb.find(candidate_ids)
    if summary.smiles
    and (hit := Chem.MolFromSmiles(summary.smiles)) is not None
    and hit.HasSubstructMatch(scaffold)
]
print(f"{len(candidate_ids)} components searched, {len(related)} share the scaffold\n")
for summary in related:
    print(f"  {summary.id}  {summary.formula:<14} {summary.name[:62]}")

Output:

103 of 400 blinded compounds are built on that scaffold
100 components searched, 3 share the scaffold

  A1B8V  C17 H16 N4 O   N-(2,3-dihydro-1H-isoindol-5-yl)-2-methyl-2H-indazole-4-carbox
  A1B9F  C16 H13 F N4 O N-(2,3-dihydro-1H-isoindol-5-yl)-6-fluoro-1H-indazole-4-carbox
  A1JHN  C16 H13 Cl N4 O 6-chloranyl-~{N}-(2,3-dihydro-1~{H}-isoindol-5-yl)-1~{H}-indaz
# Is any of the 400 already deposited? Compare InChIKeys, and their first block
# alone, which encodes connectivity and so ignores stereochemistry and salt form.
blinded = dict(zip(structure_df["id"], (Chem.MolToInchiKey(m) for m in structure_df["mol"])))
skeletons = {key.split("-")[0]: name for name, key in blinded.items()}

for summary in related:
    exact = {key: name for name, key in blinded.items()}.get(summary.inchikey)
    same_skeleton = skeletons.get(summary.inchikey.split("-")[0])
    print(f"  {summary.id}: in the blinded set? {exact or 'no'} | same connectivity? {same_skeleton or 'no'}")

# Pull one of them in full. This is experimental geometry, not a prediction.
template = wwpdb.component(related[0].id)
print(f"\n{template.id}: {len(template.atoms)} atoms, {len(template.bonds)} bonds")
print(f"  {template.smiles}")
print(f"  first atom {template.atoms[0].id} at "
      f"({template.atoms[0].x:.2f}, {template.atoms[0].y:.2f}, {template.atoms[0].z:.2f})")
print("\nwwpdb.to_sdf(template) gives a block you can hand to RDKit as a reference conformer.")

Output:

  A1B8V: in the blinded set? no | same connectivity? no
  A1B9F: in the blinded set? no | same connectivity? no
  A1JHN: in the blinded set? no | same connectivity? no

A1B8V: 38 atoms, 41 bonds
  Cn1cc2c(cccc2C(=O)Nc3ccc4CNCc4c3)n1
  first atom N1 at (4.60, -1.54, -0.26)

wwpdb.to_sdf(template) gives a block you can hand to RDKit as a reference conformer.

6. What actually placed 2nd

The sections above follow the organisers' tutorial, which uses Boltz-2. That baseline scores 30.5% on the live leaderboard. The entry that reached 2nd place at 72.5% changed three things, and each one was measured rather than guessed.

A different co-folding model. Protenix protenix_base_20250630_v1.0.0 instead of OpenBind-0. It shares OpenBind-0's 2025-06-30 data cutoff, so the comparison is fair. On the consortium's own released per-sample benchmark, re-scored at this challenge's criterion (BiSyRMSD 0.8), Protenix wins by 8.8 points per sample across 590 interfaces. The gap is largest where the incumbent is most in-domain: in the top training-similarity bin it is +16.0 points, 86.1% against 70.1%, with the paired test at p = 2e-06. That is the regime this challenge sits in, since 149 ASAP Zika structures were public before both models' cutoff.

No geometry repair. The obvious move is to "fix" poses that fail PoseBusters by minimising them. Measured on real structures with the organisers' own scorer, a 0.96 A ligand displacement (the median our repair step applied) costs a full 0.96 A of BiSyRMSD and drops lDDT-PLI from 1.00 to about 0.86. Meanwhile PoseBusters is free: nine of seventeen leaderboard entries sit at 200/200, the 64.5% baseline among them, and it performs no repair at all. So repair has no upside and a real cost. Select a sample that already passes instead.

Medoid over the passing samples, computed after superposition. This is the subtle one and it is easy to get wrong.

The frame trap

Every diffusion sample comes out in its own global frame. Comparing ligand coordinates between two samples without first superposing the protein measures the frame, not the pose. Measured on two samples of the same compound:

CA RMSD, no superposition:                26.74 A
CA RMSD, after superposition:              1.13 A
LIGAND RMSD after protein superposition:   0.16 A

Those two samples are nearly identical. A naive comparison calls them 27 A apart. The same applies to scoring against a crystal structure, which is why the challenge uses BiSyRMSD: it superposes the binding site first, and correctly reports 0.000 for a whole-complex rigid motion where a naive ligand RMSD reports up to 18.8 A.

"""Medoid selection over PoseBusters-passing samples, superposition-aware.

Pose geometry is never modified. For each compound we keep only the samples that already
pass PoseBusters, superpose each one's CA atoms onto a common reference, apply that
transform to the ligand, and take the sample whose ligand is closest on average to the
others. That is the mode of the ensemble, which is the one selection signal that beat
chance in our testing.
"""
import itertools
import numpy as np
import gemmi
from rdkit import Chem
from rdkit.Chem import rdMolAlign


def ca_and_ligand(path, lig_resname="LIG"):
    st = gemmi.read_structure(path)
    st.remove_hydrogens()
    ca, lig = [], []
    for chain in st[0]:
        for res in chain:
            for atom in res:
                if res.name == lig_resname:
                    lig.append([atom.pos.x, atom.pos.y, atom.pos.z])
                elif atom.name == "CA":
                    ca.append([atom.pos.x, atom.pos.y, atom.pos.z])
    return np.array(ca), np.array(lig)


def kabsch(P, Q):
    """Rotation taking centred P onto centred Q."""
    U, _, Vt = np.linalg.svd(P.T @ Q)
    d = np.sign(np.linalg.det(Vt.T @ U.T))
    return Vt.T @ np.diag([1, 1, d]) @ U.T


def medoid_pose(paths):
    """Return the path of the medoid sample, or None if nothing is comparable."""
    geom = {p: ca_and_ligand(p) for p in paths}
    ref_ca, _ = geom[paths[0]]
    mols = {}
    for p in paths:
        ca, lig = geom[p]
        n = min(len(ca), len(ref_ca))
        if n == 0 or len(lig) == 0:
            continue
        cm, rm = ca[:n].mean(0), ref_ca[:n].mean(0)
        R = kabsch(ca[:n] - cm, ref_ca[:n] - rm)
        aligned = (lig - cm) @ R.T + rm           # ligand into the common frame
        mol = Chem.MolFromPDBFile(p, removeHs=True, sanitize=False)
        lm = Chem.SplitMolByPDBResidues(mol).get("LIG") if mol else None
        if lm is None or lm.GetConformer().GetNumAtoms() != len(aligned):
            continue
        conf = lm.GetConformer()
        for i, xyz in enumerate(aligned):
            conf.SetAtomPosition(i, xyz.tolist())
        mols[p] = lm

    keys = list(mols)
    if not keys:
        return None
    if len(keys) == 1:
        return keys[0]
    D = np.full((len(keys), len(keys)), np.nan)
    for i, j in itertools.combinations(range(len(keys)), 2):
        try:
            v = float(rdMolAlign.CalcRMS(mols[keys[i]], mols[keys[j]]))   # symmetry-corrected
        except Exception:
            v = np.nan
        D[i, j] = D[j, i] = v
    return keys[int(np.nanargmin(np.nanmean(D, axis=1)))]


print("medoid_pose() ready: pass it the PoseBusters-passing samples for one compound")
Running the generation step

Protenix is a separate package and needs a GPU, so this is the command rather than a cell you run here. 5 seeds x 5 samples gives 25 poses per compound.

pip install protenix
protenix pred \
    -i queries.json \
    -o out/ \
    -n protenix_base_20250630_v1.0.0 \
    -s 101,102,103,104,105 \
    -e 5

Two practical notes that cost us a day. Protenix pulls torch 2.7.1+cu126; inside a container built on an older CUDA it will bind the system cuDNN and abort with undefined symbol: cudnnGetLibConfig. Put torch's own bundled libraries first:

SP=$(python -c "import site;print(site.getsitepackages()[0])")
export LD_LIBRARY_PATH="$(find $SP/nvidia -maxdepth 2 -name lib -type d | tr '\n' ':')$LD_LIBRARY_PATH"

And the sample-count flag is -e/--sample, not --n_sample.

The query JSON takes one entry per compound, with the two protein chains and the ligand SMILES. Precomputed MSAs go in unpairedMsaPath per chain; omit them and the model runs MSA-free, which is a large accuracy loss that produces no error message.

# Build Protenix queries for all 400 blinded compounds.
# NS2B and NS3 are separate chains; the ligand is the third entity.
import json

NS2B = "SMGKSVDMYIERAGDITWEKDAEVTGNSPRLDVALDESGDFSLVEE"
NS3 = ("MKEVKKGETTDGVYRVMTRRLLGSTQVGVGVMQEGVFHTMWHVTKGAALRSGEGRLDPYWGDVKQDLVSYCGPWKLDAAWDGLSEVQ"
       "LLAVPPGERAKNIQTLPGIFKTKDGDIGAVALDYPAGTSGSPILDKCGRVIGLYGNGVVIKNGSYVSAITQGKREEETPVE")


def protenix_query(name, smiles, ns2b_msa=None, ns3_msa=None):
    def chain(seq, msa):
        c = {"count": 1, "sequence": seq}
        if msa:
            c["unpairedMsaPath"] = msa      # absolute path; omitting it runs MSA-free
        return {"proteinChain": c}
    return {
        "name": name,
        "covalent_bonds": [],
        "sequences": [chain(NS2B, ns2b_msa), chain(NS3, ns3_msa),
                      {"ligand": {"count": 1, "ligand": smiles}}],
    }


queries = [protenix_query(r["Molecule_Name"], r["SMILES"])
           for _, r in structure_df[["Molecule_Name", "SMILES"]].iterrows()]
print(f"{len(queries)} queries ready")
print(json.dumps(queries[0], indent=1)[:420])

MSAs for these two chains. protenix_query takes an MSA path per chain and runs without one if you leave it out. structure-prediction-msas.ipynb, in your home folder next to this notebook, builds MSAs for NS2B and NS3 with scigantic_msa from published open alignments, sending the sequences nowhere, and writes Boltz, Chai-1 and AlphaFold 3 inputs for all 400 compounds. write_model("protenix", [ns2b, ns3], out_dir) from the same library writes the Protenix files.

What it scored, and what it does not fix

On the live leaderboard this reached 72.5%, 2nd place, with the lowest mean BiSyRMSD of any entry (1.5559, against the leader's 1.6324). Both gates moved together relative to the previous submission, 125 to 145 on BiSyRMSD and 144 to 156 on lDDT-PLI, which is what a genuinely better generator looks like rather than a threshold artefact.

Things that did not help, each tested and measured, so you can skip them:

triedresult
Model confidence as a pose selector (pLDDT, PAE, ranking_score)at or below random
Cross-model agreementinverted, rho -0.293
Pocket constraints as input conditioningsignificantly worse, p = 1e-23
Inverse-model sequence recovery (LigandMPNN)no within-compound signal
A paired NS2B/NS3 MSA (602 exact pairs, built from flavivirus polyproteins)null, p = 1.000
An apo template to fix pocket geometrynull, and the pocket was never wrong
Inference-time steering (--use_tfg_guidance)3x the cost, negative on the wider benchmark

The failure that survives everything: on small, un-anchored fragments the model places the ligand 20 to 23 A away in a different pocket, fully buried, with burial indistinguishable from the poses it gets right and no confidence signal flagging it. The protein is correct in those cases (lDDT-LP around 0.97) and so is the pocket. It is a placement failure, not an information deficit, which is why supplying more information did nothing.

Great! You can now submit!

Go to the web portal and submit there, carefully filling in your information.

https://huggingface.co/spaces/openadmet/openbind-blind-challenge-1

Run it

Open this notebook to run it, see the dataset page for the full description, or browse the full catalog.