RFD4-Proteina: Generation speed, reward-guided search

Prerequisites

Conditions: Linux x86_64 host, Python 3.12, NVIDIA GPU with a CUDA 13-compatible driver; hosts with CUDA 12 drivers use the manual installation branch in step 2.

Table: Model and installation requirements

Step by step

1. Define the target and conditions. Supply an annotated CIF, a molecular file format containing structures and annotations, or a condition specification with its source structure file. The tutorial targets a cropped PDB 5O45 structure and specifies Tyr56·Met115·Tyr123 hotspots, or binding sites. It designs a new binder, a protein that binds the target, with 100~150 residues, or amino acid units.

git clone https://github.com/RosettaCommons/RFD4-Proteina.git
cd RFD4-Proteina
cat > pdl1.json <<'JSON'
{
"pdl1_binder": {
"input": "docs/examples/inputs/5o45_cropped.cif",
"contig": "100-150, /0, A17-131",
"conditions": {
"C_CRD": {"true": [{"select": "sel('A') and is_protein_backbone"}]},
"C_SEQ": {"true": [{"select": "sel('A')"}]},
"C_HOT": {"true": [
{"select": "sel('A/*/56/[CG,OH]')"},
{"select": "sel('A/*/115/[CG,SD]')"},
{"select": "sel('A/*/123/[CD2,OH]')"}
]}
}
}
}
JSON

2. Prepare the environment. For the open model, the repository script downloads both the environment and the Hugging Face weights bundle using the CUDA 13 profile. uv was validated at 0.12.24; update an existing installation to recognize CUDA 13.2.

bash setup.sh --native
source .venv/bin/activate

On hosts with CUDA 12 drivers, manually install the CUDA 12 profile instead of using the script in the repository cloned in step 1.

# 한 환경에 CUDA extra는 하나만 설치한다, 선택형 BioIR 백엔드는 CUDA 13 전용
python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install "uv>=0.13.4"
uv pip install --no-sources --torch-backend cu126 -e '.[all-cuda12]'
export DATA_PATH="${DATA_PATH:-$PWD/data_path}"
./scripts/download_assets.sh "$DATA_PATH" --skip-of3
bash scripts/setup_search_envs.sh

For NIM, log in with an NGC API key and launch the container on port 8000.

read -rsp 'NGC API key: ' NGC_API_KEY; echo
export NGC_API_KEY
printf '%s' "$NGC_API_KEY" | docker login nvcr.io \
-u '$oauthtoken' --password-stdin
image=nvcr.io/nim/ipd/rfd4-proteina:latest
docker pull "$image"
export RFD4_NIM_IMAGE="$(docker image inspect \
--format '{{index .RepoDigests 0}}' "$image")"
printf '%s\n' "$RFD4_NIM_IMAGE" > nim-image.txt
export LOCAL_NIM_CACHE="$HOME/.cache/nim"
mkdir -p "$LOCAL_NIM_CACHE"
docker run -d --rm --name rfd4-proteina \
--runtime=nvidia --gpus 'device=0' -p 8000:8000 \
-e NGC_API_KEY -v "$LOCAL_NIM_CACHE":/opt/nim/.cache \
--shm-size=16g "$RFD4_NIM_IMAGE"

3. Generate candidates. Outputs accumulate under runs/pdl1-open/inference_samples/; add num_replicates=10 to generate multiple candidates. Save the following script as design.py in the repository root.

# design.py
import hydra
from rfd4_proteina import Proteina
from rfproteina.generate import run_generation

@hydra.main(config_path="configs", config_name="inference", version_base="1.3")
def main(cfg):
    model = Proteina.from_pretrained("nvidia/RFD4-Proteina")
    run_generation(cfg, model=model)

if __name__ == "__main__":
    main()

python design.py inputs=pdl1.json out_dir=runs/pdl1-open seed=42 compile_lengths=null

4. Search with rewards. The search preset scores at steps 20·40·50·60 with 2 branches and a beam width of 3, the number of candidates retained simultaneously. The reward is OpenFold3 pLDDT, a predicted structure confidence score, with a floor of 50. Rollouts, each consisting of one generation and evaluation cycle, are saved for rewards of 80 or above.

python design.py inference_experiment=inference_beam_example \
metrics/refolding_oracles=of3 inputs=pdl1.json subset_to_examples=null \
num_replicates=1 out_dir=runs/pdl1-open-search seed=42 compile_lengths=null

The NIM route calls the generation endpoint with the same condition specification and target CIF. Save the following script as nim_client.py in the repository root.

# nim_client.py
import json
from pathlib import Path
import requests

spec = json.loads(Path("pdl1.json").read_text())["pdl1_binder"]
target = Path(spec["input"])
spec["input"] = target.name
payload = {
    "task": "motif_scaffolding",
    "input": {"format": "condition_spec", "example_id": "pdl1_binder",
              "spec": spec,
              "files": [{"filename": target.name, "content": target.read_text()}]},
    "sampling": {"num_replicates": 1, "seed": 42},
    "metrics": {"tags": ["design", "hotspot_conditioning"]},
}

def submit(payload, out):
    out.mkdir(parents=True, exist_ok=True)
    response = requests.post(
        "http://localhost:8000/biology/ipd/rfd4-proteina/generative",
        json=payload, timeout=1800)
    response.raise_for_status()
    result = response.json()
    (out / "response.json").write_text(json.dumps(result, indent=2))
    for i, design in enumerate(result["designs"]):
        dest = out / f"design-{i}.cif"
        dest.write_text(design["structure"]["content"])
        print(design["design_id"], dest)

if __name__ == "__main__":
    submit(payload, Path("runs/pdl1-nim"))

python -m pip install requests
python nim_client.py

How fast is it?

Conditions: 200 residues, batch size 1, NVIDIA H200; RFD4-Proteina uses 60-step medium thinking / RFD3 uses 200 schedule points. Source: NVIDIA Technical Blog Figure 2.

Table: RFD4-Proteina and RFD3 generation performance comparison

NVIDIA reports reductions in both latency and memory. These come from residue-level latent representations, vectors that compress structures, and a revised diffusion process that reconstructs structures from noise. Sampling steps, the iterations that update candidates, fell from about 400 in Proteina-Complexa to 60.

Conditions: 6 tested Hopper GPU configurations, batch size 1, summed end-to-end times after warmup for 15 sequence lengths of 128~1,024 tokens. Baseline: default compilation backend. Source: NVIDIA Technical Blog Figure 4.

Table: BioIR speedup by Hopper GPU

Unit: times

How far has validation progressed?

Conditions: Experimental results reported in the project preprint, a paper released before peer review; conditions differ by design group.

Table: Experimental validation results

The preprint reports a protein-binding cluster success rate of 10.6% for single-generation high thinking in computational benchmarks, versus 5.9% for BindCraft, with 42 times the throughput. This metric counts only distinct structures that pass task-specific computational criteria after designed sequences are refolded with AlphaFold3. It is separate from the experimental validation results in the table.

Common stumbling blocks

1. Weight access. If Hugging Face repository access is restricted, pass HF_TOKEN or authenticate with hf auth login. 2. Oracle environment. The OpenFold3 runtime and weights are optional installations, and the GPU host needs Apptainer. In NIM, mount the reward.py callback, set NIM_ALLOW_ORACLE_PLUGIN=true and OF3_NIM_API_KEY, and restart the service. 3. Search result counts vary between runs. Inspect generated CIFs and retained metrics directly to select candidates. Do not rely on a single score; also check interface metrics such as ipTM·ipSAE, which assess binding-interface structures and contacts.

Limitations

The pLDDT reward measures predicted confidence, not evidence of binding. The passing designs per GPU-hour on the Hugging Face model card were measured for a pair of earlier releases in a fixed benchmark on October 9, 2026. They should not be read as current-release performance.

Prepare a NIM-ready Linux host and run the PD-L1 specification; use the GitHub open model for development or NIM for services, and track candidates, inputs, and metrics with rfd4-proteina-campaign.