使用奖励引导推理时间搜索，使用 RFD4-Proteina 设计蛋白质

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

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

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"

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

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

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

from pathlib import Path
from nim_client import payload, submit

key = "oracle_of3_nvcf.overall_plddt"
payload["sampling"]["num_steps"] = 60
payload["search"] = {
    "step_checkpoints": [0, 20, 40, 50, 60],
    "n_branch": 2, "beam_width": 3,
    "reward_metrics_tags": ["unconditional_refolding"],
    "weights": {key: 1.0}, "clip_values": {key: {"min": 50.0}},
    "intermediate_save_min_reward": 80.0,
}
payload["metrics"] = {"tags": ["design", "unconditional_refolding"]}
submit(payload, Path("runs/pdl1-nim-search"))

docker stop rfd4-proteina
docker run -d --rm --name rfd4-proteina \
  --gpus 'device=0' -p 8000:8000 --shm-size=16g \
  -e NGC_API_KEY -v "$LOCAL_NIM_CACHE:/opt/nim/.cache" \
  -v "$PWD/reward.py:/opt/nim/reward.py:ro" \
  -e NIM_ALLOW_ORACLE_PLUGIN=true -e OF3_NIM_API_KEY \
  "$RFD4_NIM_IMAGE"

python nim_search_request.py

Use rfd4-proteina-campaign to design 100–150-residue PD-L1 binders from pdl1.json, preserving its target and hotspot constraints. Use the Hugging Face model via from_pretrained and OpenFold3. Agree on criteria and a compute budget, then compare generation with reward-guided search and run a campaign via rfd4-proteina-campaign. Return up to ten diverse candidates with scores and compute usage; package the results with rfd4-proteina-package.