Upload folder using huggingface_hub

README.md

@@ -4,25 +4,61 @@ emoji: 🧬
 colorFrom: gray
 colorTo: purple
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 6.22.0
 app_file: app.py
-short_description: Fast protein-ligand binding affinity prediction (Nesso-1)
+short_description: Protein-ligand binding affinity with Nesso-1
 python_version: "3.12"
 startup_duration_timeout: 1h
-pinned: false
+models:
+  - recursionpharma/nesso
+  - facebook/esm2_t33_650M_UR50D
+tags:
+  - binding-affinity
+  - protein-ligand
+  - drug-discovery
 ---
 
-# Nesso-1 · Protein–Ligand Binding Affinity
+# Nesso-1 — binding affinity prediction
 
-Interactive demo of [`recursionpharma/nesso`](https://huggingface.co/recursionpharma/nesso)
-(Nesso-1) — a fast, structure-based protein–ligand binding-affinity prediction model from
-[Valence Labs](https://valencelabs.com) (a Recursion company).
+Predict protein–ligand binding affinity from **an amino-acid sequence and a SMILES
+string** — no MSA and no input structure required.
 
-Provide a protein amino-acid sequence and a ligand (SMILES) and the model predicts the
-binding affinity as log₁₀(IC₅₀ / µM) plus a binder / non-binder probability.
+[Nesso-1](https://huggingface.co/recursionpharma/nesso) is a coarse-grained cofolding
+model from Valence Labs (Recursion), released under Apache-2.0
+([code](https://github.com/recursionpharma/nesso),
+[technical report](https://www.biorxiv.org/content/10.64898/2026.08.01.742196v1)).
 
-- Model card: https://huggingface.co/recursionpharma/nesso
-- Code: https://github.com/recursionpharma/nesso
-- License: Apache-2.0
+## What the Space runs
 
-Example inputs are taken from the Nesso-1 tutorial in the official repository.
+The app reproduces the reference `nesso predict` pipeline
+([docs/prediction.md](https://github.com/recursionpharma/nesso/blob/main/docs/prediction.md))
+directly in-process, so the numbers match the CLI:
+
+- RDKit ETKDG conformer generation for the ligand and CCD-backed protein tokenisation,
+- ESM-2 650M (`facebook/esm2_t33_650M_UR50D`) single-sequence embeddings,
+- Nesso-1 trunk with 5 recycling steps, two-stage pocket refinement
+  (`refine_protein_cutoff=22 Å`, 256-token budget), `affinity_protein_cutoff=15 Å`,
+- `bf16-mixed` precision, and the model's own `predict_step` / `affinity.json` scalars.
+
+cuEquivariance kernels are not installed (they are CUDA-12 only), which is the
+`--no_kernels`-equivalent fall-back to the pure-PyTorch path; results are unchanged.
+
+## Reading the output
+
+`affinity_pred_value` is log₁₀(IC₅₀ / µM): **−3 ≈ 1 nM** (strong binder), **0 ≈ 1 µM**,
+**+2 ≈ 100 µM** (weak / non-binder). `affinity_probability_binary` is the binder
+classification probability. `entropy_crop_pl` is the model's confidence in the predicted
+protein–ligand interface — **0.0 means the ligand could not be confidently placed and the
+prediction should not be trusted**.
+
+Research use only. Not for clinical or diagnostic use.
+
+## Examples
+
+- *Nesso tutorial complex + L-tyrosine* — the authors' own example from
+  [`tutorial/smiles.yaml`](https://github.com/recursionpharma/nesso/blob/main/tutorial/smiles.yaml)
+  (Apache-2.0).
+- ABL1 / EGFR kinase domains and CDK2 — sequences from
+  [UniProt](https://www.uniprot.org) (P00519, P00533, P24941; CC-BY 4.0).
+- Imatinib, gefitinib, staurosporine and caffeine SMILES from
+  [PubChem](https://pubchem.ncbi.nlm.nih.gov) (public domain).

app.py

@@ -1,279 +1,444 @@
+"""Nesso-1 — protein–ligand binding affinity prediction on ZeroGPU.
+
+Mirrors the reference `nesso predict` CLI path (see
+https://github.com/recursionpharma/nesso, docs/prediction.md): same
+preprocessing (RDKit ETKDG conformer + CCD-backed protein tokenisation),
+same ESM-2 650M embeddings, same defaults (5 recycling steps, two-stage
+pocket refinement, bf16-mixed precision), same `predict_step`.
+"""
+
 import os
 
-# Point every cache (nesso checkpoint, CCD dict, ESM-2 weights) at a persistent,
-# writable location so downloads happen once and are reused across GPU calls.
-os.environ.setdefault("NESSO_CACHE", "/tmp/nesso_cache")
-os.environ.setdefault("HF_HOME", "/tmp/nesso_cache/huggingface")
-os.environ.setdefault("HF_HUB_CACHE", "/tmp/nesso_cache/huggingface")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
 
-import spaces  # noqa: E402  — must precede torch / CUDA-touching imports
+import spaces  # noqa: E402  — must precede any CUDA-touching import
 
-import json  # noqa: E402
+import hashlib  # noqa: E402
 import tempfile  # noqa: E402
 import time  # noqa: E402
 from pathlib import Path  # noqa: E402
 
 import gradio as gr  # noqa: E402
-import yaml as pyyaml  # noqa: E402
-
-
-TITLE = "Nesso-1 · Protein–Ligand Binding Affinity"
-
-DESCRIPTION = """
-# 🧬 Nesso-1 · Binding Affinity Prediction
-
-**[Nesso-1](https://huggingface.co/recursionpharma/nesso)** is a fast, structure-based
-protein–ligand binding-affinity model from
-[Valence Labs](https://valencelabs.com) (a Recursion company). Give it a **protein
-amino-acid sequence** and a **ligand** (as a SMILES string), and it predicts binding
-affinity (as log₁₀(IC₅₀ / µM)) together with a binder / non-binder probability.
-
-Lower affinity ⇒ stronger binding: `-3.0 ≈ 1 nM` (strong) · `0.0 ≈ 1 µM` (moderate) ·
-`2.0 ≈ 100 µM` (weak).
-
-Links: [Model card](https://huggingface.co/recursionpharma/nesso) ·
-[Code](https://github.com/recursionpharma/nesso) ·
-[Blog](https://huggingface.co/blog/recursionpharma/nesso1)
-"""
-
-# A representative protein used by the model authors' own tutorial examples.
-EXAMPLE_PROTEIN = (
-    "MVTPEGNVSLVDESLLVGVTDEDRAVRSAHQFYERLIGLWAPAVMEAAHELGVFAALAEAPADSGELARRLDCDARAMRVLLDALYAY"
-    "DVIDRIHDTNGFRYLLSAEARECLLPGTLFSLVGKFMHDINVAWPAWRNLAEVVRHGARDTSGAESPNGIAQEDYESLVGGINFWAPP"
-    "IVTTLSRKLRASGRSGDATASVLDVGCGTGLYSQLLLREFPRWTATGLDVERIATLANAQALRLGVEERFATRAGDFWRGGWGTGYDL"
-    "VLFANIFHLQTPASAVRLMRHAAACLAPDGLVAVVDQIVDADREPKTPQDRFALLFAASMTNTGGGDAYTFQEYEEWFTAAGLQRIET"
-    "LDTPMHRILLARRATEPSAVPEGQASENLYFQ"
+import torch  # noqa: E402
+from huggingface_hub import hf_hub_download  # noqa: E402
+from rdkit import Chem, RDLogger  # noqa: E402
+from rdkit.Chem import Draw  # noqa: E402
+from safetensors.torch import save_file  # noqa: E402
+
+from nesso.data import const  # noqa: E402
+from nesso.data.esm import (  # noqa: E402
+    DEFAULT_ESM2_MODEL,
+    extract_esm_embedding,
+    setup_esm_model,
 )
-
-
-def _build_yaml(protein_seq: str, ligand_smiles: str) -> str:
-    doc = {
-        "sequences": [
-            {"protein": {"id": "A", "sequence": protein_seq.strip()}},
-            {"ligand": {"id": "B", "smiles": ligand_smiles.strip()}},
-        ],
-        "properties": [{"affinity": {"binder": "B"}}],
+from nesso.data.featurizer import NessoFeaturizer  # noqa: E402
+from nesso.data.inference import (  # noqa: E402
+    STANDARD_AA,
+    InferenceDataset,
+    inference_collate,
+)
+from nesso.data.types import Manifest  # noqa: E402
+from nesso.data.yaml_input import (  # noqa: E402
+    load_ccd_mol_dict,
+    parse_schema,
+    validate_schema,
+)
+from nesso.model.models.nesso1 import Nesso1  # noqa: E402
+
+RDLogger.DisableLog("rdApp.*")
+
+REPO_ID = "recursionpharma/nesso"
+REVISION = "v1.0.0"
+MAX_RESIDUES = 1200
+DEFAULT_RECYCLING = 5
+
+# --------------------------------------------------------------------------------------
+# Load everything once, at module scope (ZeroGPU packs the weights at startup).
+# --------------------------------------------------------------------------------------
+print("Downloading Nesso-1 assets…", flush=True)
+CCD_PATH = Path(hf_hub_download(REPO_ID, "ccd.pkl", revision=REVISION))
+WEIGHTS_PATH = Path(
+    hf_hub_download(REPO_ID, f"{REVISION}/model.safetensors", revision=REVISION)
+)
+hf_hub_download(REPO_ID, f"{REVISION}/hparams.json", revision=REVISION)
+
+print("Loading CCD dictionary…", flush=True)
+CCD_DICT = load_ccd_mol_dict(CCD_PATH)
+STD_AA_MOLS = {aa: CCD_DICT.get(aa) for aa in STANDARD_AA}
+
+print("Loading Nesso-1…", flush=True)
+MODEL = Nesso1.from_pretrained(WEIGHTS_PATH.parent)
+# Same predict_args the CLI sets (docs/prediction.md defaults).
+MODEL.predict_args.update(
+    {
+        "pose_protein_cutoff": 15.0,
+        "recycling_steps": DEFAULT_RECYCLING,
+        "affinity_protein_cutoff": 15.0,
+        "refine_protein_inference": True,
+        "refine_protein_cutoff": 22.0,
+        "refine_protein_tokens_budget": 256,
+        "save_metadata": False,
     }
-    return pyyaml.safe_dump(doc, sort_keys=False)
-
-
-class _SerialExecutor:
-    """Drop-in for ProcessPoolExecutor that runs tasks inline in the current
-    process. Required on ZeroGPU: the @spaces.GPU worker is a daemonic fork and
-    cannot spawn child processes ("daemonic processes are not allowed to have
-    children"). Honors the initializer/initargs so nesso's per-worker CCD dict
-    global is populated in-process.
-    """
-
-    def __init__(self, max_workers=None, initializer=None, initargs=()):
-        if initializer is not None:
-            initializer(*initargs)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc):
-        return False
-
-    def submit(self, fn, *args, **kwargs):
-        from concurrent.futures import Future
-
-        fut = Future()
-        try:
-            fut.set_result(fn(*args, **kwargs))
-        except BaseException as exc:  # noqa: BLE001
-            fut.set_exception(exc)
-        return fut
-
-
-def _patch_nesso_multiprocessing():
-    """Replace nesso.main's ProcessPoolExecutor with the serial shim."""
-    import nesso.main as nm
-
-    nm.ProcessPoolExecutor = _SerialExecutor
-
-
-def _run_nesso_cli(yaml_path: Path, out_dir: Path, recycling_steps: int, seed: int):
-    """Invoke the official `nesso predict` command in-process (Click callback)."""
-    from click.testing import CliRunner
-    from nesso.main import cli
-
-    _patch_nesso_multiprocessing()
-
-    args = [
-        "predict",
-        str(yaml_path),
-        "--out_dir",
-        str(out_dir),
-        "--accelerator",
-        "gpu",
-        "--recycling_steps",
-        str(int(recycling_steps)),
-        "--num_workers",
-        "0",
-        "--seed",
-        str(int(seed)),
-    ]
+)
+MODEL.eval()
+MODEL.to("cuda")
+
+print("Loading ESM-2 650M…", flush=True)
+ESM_MODEL, ESM_TOKENIZER = setup_esm_model(DEFAULT_ESM2_MODEL, torch.device("cuda"))
+
+torch.set_grad_enabled(False)
+torch.set_float32_matmul_precision("highest")
+print("Ready.", flush=True)
+
+VALID_AA = set(const.prot_letter_to_token) - {"-"}
+
+
+# --------------------------------------------------------------------------------------
+# Helpers
+# --------------------------------------------------------------------------------------
+def _clean_sequence(raw: str) -> str:
+    """Normalise a pasted protein sequence (accepts FASTA, whitespace, lowercase)."""
+    lines = [ln for ln in (raw or "").splitlines() if not ln.strip().startswith(">")]
+    seq = "".join("".join(lines).split()).upper()
+    seq = "".join(ch for ch in seq if not ch.isdigit())
+    return seq
+
+
+def _format_affinity(value: float) -> str:
+    """log10(IC50 / uM) -> a human-readable concentration."""
+    ic50_um = 10.0**value
+    if ic50_um < 1e-3:
+        return f"{ic50_um * 1e6:.2f} pM"
+    if ic50_um < 1.0:
+        return f"{ic50_um * 1e3:.2f} nM"
+    if ic50_um < 1e3:
+        return f"{ic50_um:.2f} µM"
+    return f"{ic50_um / 1e3:.2f} mM"
+
+
+def _strength(value: float) -> str:
+    if value <= -2.0:
+        return "very strong (low-nM or better)"
+    if value <= -1.0:
+        return "strong"
+    if value <= 0.0:
+        return "moderate"
+    if value <= 1.0:
+        return "weak"
+    return "very weak / likely non-binder"
+
+
+def _estimate_duration(
+    protein_sequence: str = "",
+    ligand_smiles: str = "",
+    recycling_steps: int = DEFAULT_RECYCLING,
+    *args,
+    **kwargs,
+) -> int:
+    try:
+        n = len(_clean_sequence(protein_sequence)) or 400
+    except Exception:
+        n = 400
     try:
-        runner = CliRunner(mix_stderr=False)
-    except TypeError:
-        # Click >= 8.2 removed the mix_stderr kwarg.
-        runner = CliRunner()
-    result = runner.invoke(cli, args, catch_exceptions=True)
-    return result
+        steps = int(recycling_steps)
+    except Exception:
+        steps = DEFAULT_RECYCLING
+    return int(min(220, 25 + 0.05 * n + 4 * steps))
 
 
-@spaces.GPU(duration=180)
+# --------------------------------------------------------------------------------------
+# Inference
+# --------------------------------------------------------------------------------------
+@spaces.GPU(duration=_estimate_duration)
 def predict_affinity(
-    protein_seq: str,
+    protein_sequence: str,
     ligand_smiles: str,
-    recycling_steps: int = 5,
+    recycling_steps: int = DEFAULT_RECYCLING,
     seed: int = 42,
     progress=gr.Progress(track_tqdm=True),
 ):
-    """Predict protein–ligand binding affinity with Nesso-1.
+    """Predict the binding affinity between a protein and a small molecule.
 
     Args:
-        protein_seq: Target protein amino-acid sequence (single-letter codes).
+        protein_sequence: Target protein as a single-letter amino-acid sequence (FASTA accepted).
         ligand_smiles: Ligand as a SMILES string.
-        recycling_steps: Number of trunk recycling iterations (higher = more compute).
-        seed: Random seed for reproducibility.
+        recycling_steps: Number of trunk recycling iterations (Nesso-1 default is 5).
+        seed: Random seed (controls RDKit conformer generation and featurisation).
 
     Returns:
-        A markdown summary of the predicted binding affinity and binder probability,
-        and the full raw prediction JSON.
+        A 2D depiction of the ligand, a Markdown summary, the binder/non-binder
+        probabilities, and the raw `affinity.json` scalars produced by Nesso-1.
     """
-    protein_seq = (protein_seq or "").strip().replace("\n", "").replace(" ", "")
-    ligand_smiles = (ligand_smiles or "").strip()
-    if not protein_seq:
+    seq = _clean_sequence(protein_sequence)
+    if not seq:
         raise gr.Error("Please provide a protein amino-acid sequence.")
-    if not ligand_smiles:
+    bad = sorted(set(seq) - VALID_AA)
+    if bad:
+        raise gr.Error(f"Unsupported characters in the protein sequence: {bad}")
+    if len(seq) > MAX_RESIDUES:
+        raise gr.Error(
+            f"Sequence has {len(seq)} residues; this demo is capped at {MAX_RESIDUES}. "
+            "Paste the target domain (e.g. the kinase domain) instead of the full protein."
+        )
+
+    smiles = (ligand_smiles or "").strip()
+    if not smiles:
         raise gr.Error("Please provide a ligand SMILES string.")
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        raise gr.Error(f"RDKit could not parse the SMILES string: {smiles!r}")
+
+    steps = max(0, min(10, int(recycling_steps)))
+    seed = int(seed)
+
+    from lightning.pytorch import seed_everything
+
+    seed_everything(seed, workers=True)
+
+    ligand_png = Draw.MolToImage(mol, size=(420, 320))
 
     t0 = time.perf_counter()
-    work = Path(tempfile.mkdtemp(prefix="nesso_"))
-    yaml_path = work / "complex.yaml"
-    yaml_path.write_text(_build_yaml(protein_seq, ligand_smiles))
-    out_dir = work / "output"
-
-    result = _run_nesso_cli(yaml_path, out_dir, recycling_steps, seed)
-
-    # Locate the produced affinity.json
-    affinity_files = list(out_dir.glob("predictions/*/affinity.json"))
-    if not affinity_files:
-        stdout = getattr(result, "stdout", "") or ""
-        stderr = getattr(result, "stderr", "") or ""
-        exc = ""
-        if getattr(result, "exception", None) is not None:
-            import traceback
-
-            exc = "".join(
-                traceback.format_exception(
-                    type(result.exception),
-                    result.exception,
-                    result.exception.__traceback__,
-                )
-            )
-        raise gr.Error(
-            "Prediction failed — no output produced.\n"
-            f"stdout:\n{stdout[-1500:]}\n\nstderr:\n{stderr[-1500:]}\n\n{exc[-1500:]}"
+    work = Path(tempfile.mkdtemp(prefix="nesso-"))
+    processed = work / "processed"
+    mol_dir = processed / "rdkit_conformers"
+    structures_dir = processed / "structures"
+    records_dir = processed / "records"
+    esm_dir = processed / "esm_embeddings"
+    for d in (mol_dir, structures_dir, records_dir, esm_dir):
+        d.mkdir(parents=True, exist_ok=True)
+
+    record_id = "complex"
+    schema = {
+        "sequences": [
+            {"protein": {"id": "A", "sequence": seq}},
+            {"ligand": {"id": "B", "smiles": smiles}},
+        ],
+        "properties": [{"affinity": {"binder": "B"}}],
+    }
+    validate_schema(schema)
+
+    try:
+        structure, record, entity_to_seq, _ = parse_schema(
+            schema, mol_dir, ccd_dict=CCD_DICT, record_id=record_id
         )
+    except Exception as exc:  # noqa: BLE001
+        raise gr.Error(f"Could not build the complex: {exc}") from exc
+
+    structure.dump(structures_dir / f"{record_id}.npz")
+    record.dump(records_dir / f"{record_id}.json")
+
+    # ESM-2 embeddings (same code path as the CLI's `run_esm`).
+    for protein_seq in entity_to_seq.values():
+        mid = hashlib.md5(protein_seq.encode("utf-8")).hexdigest()  # noqa: S324
+        out_path = esm_dir / f"{mid}.safetensors"
+        if not out_path.exists():
+            emb = extract_esm_embedding(protein_seq, ESM_MODEL, ESM_TOKENIZER)
+            save_file({"embeddings": emb}, out_path)
+
+    featurizer = NessoFeaturizer(
+        esm_emb_dir=esm_dir, esm_emb_dim=1280, esm_num_layers=33
+    )
+    dataset = InferenceDataset(
+        manifest=Manifest([record]),
+        target_dir=processed,
+        featurizer=featurizer,
+        ligand_dir=mol_dir,
+        ccd_pkl=None,
+        use_esm_all_layers=False,
+    )
+    # Reuse the CCD-backed standard residues loaded once at startup.
+    dataset._standard_aa_mols = STD_AA_MOLS  # noqa: SLF001
+
+    feats = dataset[0]
+    if feats.get("exception"):
+        raise gr.Error("Featurisation failed for this complex (see the Space logs).")
+
+    batch = inference_collate([feats])
+    batch = {
+        k: (v.to("cuda", non_blocking=True) if torch.is_tensor(v) else v)
+        for k, v in batch.items()
+    }
+
+    # `--precision bf16-mixed` equivalent.
+    MODEL.predict_args["recycling_steps"] = steps
+    with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16):
+        out = MODEL.predict_step(batch, 0)
+
+    if out.get("exception"):
+        raise gr.Error("Prediction failed for this complex (see the Space logs).")
+
+    stats = {}
+    for key, value in out.items():
+        if not (key.startswith("affinity_") or key.startswith("entropy_")):
+            continue
+        if key == "entropy_pair":
+            continue
+        if torch.is_tensor(value) and value.numel() == 1:
+            stats[key] = round(float(value.item()), 4)
+        elif isinstance(value, (int, float)):
+            stats[key] = round(float(value), 4)
 
-    data = json.loads(affinity_files[0].read_text())
     elapsed = time.perf_counter() - t0
 
-    aff = data.get("affinity_pred_value")
-    prob = data.get("affinity_probability_binary")
-
-    def _ic50_str(v):
-        if v is None:
-            return "n/a"
-        # v = log10(IC50 / uM) -> IC50 in uM = 10**v
-        ic50_um = 10 ** v
-        if ic50_um < 1e-3:
-            return f"{ic50_um * 1e6:.2f} pM"
-        if ic50_um < 1.0:
-            return f"{ic50_um * 1e3:.2f} nM"
-        if ic50_um < 1e3:
-            return f"{ic50_um:.2f} µM"
-        return f"{ic50_um / 1e3:.2f} mM"
-
-    strength = ""
-    if aff is not None:
-        if aff <= -2:
-            strength = "🟢 strong binder"
-        elif aff <= 0:
-            strength = "🟡 moderate binder"
-        elif aff <= 2:
-            strength = "🟠 weak binder"
-        else:
-            strength = "🔴 very weak / non-binder"
-
-    summary = f"""### Prediction
-
-| Metric | Value |
+    affinity = stats.get("affinity_pred_value")
+    prob = stats.get("affinity_probability_binary", 0.0)
+    entropy_pl = stats.get("entropy_crop_pl")
+
+    if entropy_pl is not None and entropy_pl == 0.0:
+        confidence = (
+            "⚠️ **Low confidence** — `entropy_crop_pl` is 0.0, meaning the model could "
+            "not confidently place the ligand. Do not trust this prediction."
+        )
+    else:
+        confidence = (
+            f"Interface distogram entropy (`entropy_crop_pl`): **{entropy_pl:.3f}** "
+            "— higher is a more confident protein–ligand interface."
+        )
+
+    summary = f"""
+### Predicted binding affinity
+
+| | |
 |---|---|
-| **Binding affinity** (log₁₀ IC₅₀/µM) | `{aff:.3f}` |
-| **Estimated IC₅₀** | **{_ic50_str(aff)}** |
-| **Binder probability** | `{prob:.3f}` |
-| **Interpretation** | {strength} |
+| **log₁₀(IC₅₀ / µM)** | **{affinity:.2f}** ({_strength(affinity)}) |
+| Estimated IC₅₀ | **{_format_affinity(affinity)}** |
+| pIC₅₀ (= 6 − value) | {6.0 - affinity:.2f} |
+| Binder probability | {prob * 100:.1f}% |
+| Ensemble members | {stats.get("affinity_pred_value1", float("nan")):.2f} / {stats.get("affinity_pred_value2", float("nan")):.2f} |
 
-_Lower affinity ⇒ stronger binding. Computed in {elapsed:.1f}s._
+{confidence}
+
+<sub>{len(seq)} residues · {mol.GetNumAtoms()} heavy atoms · {steps} recycling steps · {elapsed:.1f}s</sub>
 """
-    return summary, data
 
+    label = {"binder": float(prob), "non-binder": float(1.0 - prob)}
+    return ligand_png, summary, label, stats
+
+
+# --------------------------------------------------------------------------------------
+# UI
+# --------------------------------------------------------------------------------------
+TUTORIAL_PROTEIN = (
+    "MVTPEGNVSLVDESLLVGVTDEDRAVRSAHQFYERLIGLWAPAVMEAAHELGVFAALAEAPADSGELARRLDCDARAMRVL"
+    "LDALYAYDVIDRIHDTNGFRYLLSAEARECLLPGTLFSLVGKFMHDINVAWPAWRNLAEVVRHGARDTSGAESPNGIAQED"
+    "YESLVGGINFWAPPIVTTLSRKLRASGRSGDATASVLDVGCGTGLYSQLLLREFPRWTATGLDVERIATLANAQALRLGVE"
+    "ERFATRAGDFWRGGWGTGYDLVLFANIFHLQTPASAVRLMRHAAACLAPDGLVAVVDQIVDADREPKTPQDRFALLFAASM"
+    "TNTGGGDAYTFQEYEEWFTAAGLQRIETLDTPMHRILLARRATEPSAVPEGQASENLYFQ"
+)
+ABL1_KINASE = (
+    "ITMKHKLGGGQYGEVYEGVWKKYSLTVAVKTLKEDTMEVEEFLKEAAVMKEIKHPNLVQLLGVCTREPPFYIITEFMTYGN"
+    "LLDYLRECNRQEVNAVVLLYMATQISSAMEYLEKKNFIHRDLAARNCLVGENHLVKVADFGLSRLMTGDTYTAHAGAKFPI"
+    "KWTAPESLAYNKFSIKSDVWAFGVLLWEIATYGMSPYPGIDLSQVYELLEKDYRMERPEGCPEKVYELMRACWQWNPSDRP"
+    "SFAEIHQAF"
+)
+EGFR_KINASE = (
+    "FKKIKVLGSGAFGTVYKGLWIPEGEKVKIPVAIKELREATSPKANKEILDEAYVMASVDNPHVCRLLGICLTSTVQLITQL"
+    "MPFGCLLDYVREHKDNIGSQYLLNWCVQIAKGMNYLEDRRLVHRDLAARNVLVKTPQHVKITDFGLAKLLGAEEKEYHAEG"
+    "GKVPIKWMALESILHRIYTHQSDVWSYGVTVWELMTFGSKPYDGIPASEISSILEKGERLPQPPICTIDVYMIMVKCWMID"
+    "ADSRPKFRELIIEFSKMARDPQRYL"
+)
+CDK2 = (
+    "MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVFE"
+    "FLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYTHE"
+    "VVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSFPKW"
+    "ARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHLRL"
+)
 
 CSS = """
-#col-container { max-width: 1000px; margin: 0 auto; }
+#col-container { max-width: 1200px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
 """
 
-with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title=TITLE) as demo:
+with gr.Blocks(theme=gr.themes.Citrus(), css=CSS, title="Nesso-1") as demo:
     with gr.Column(elem_id="col-container"):
-        gr.Markdown(DESCRIPTION)
-
+        gr.Markdown(
+            """
+# 🧬 Nesso-1 — binding affinity prediction
+
+Predict how strongly a small molecule binds a protein, from **sequence + SMILES only**
+(no MSA, no structure). [Nesso-1](https://huggingface.co/recursionpharma/nesso) is a
+coarse-grained cofolding model from Valence Labs (Recursion) —
+[code](https://github.com/recursionpharma/nesso) ·
+[technical report](https://www.biorxiv.org/content/10.64898/2026.08.01.742196v1).
+"""
+        )
         with gr.Row():
-            with gr.Column(scale=3):
+            with gr.Column(scale=1):
                 protein = gr.Textbox(
                     label="Protein sequence",
-                    placeholder="MKTAYIAKQ... (single-letter amino-acid codes)",
-                    lines=5,
+                    placeholder="Single-letter amino-acid sequence (FASTA is fine)…",
+                    lines=8,
+                    max_lines=12,
                 )
                 ligand = gr.Textbox(
                     label="Ligand SMILES",
-                    placeholder="e.g. N[C@@H](Cc1ccc(O)cc1)C(=O)O",
-                    lines=1,
+                    placeholder="CC1=C(C=C(C=C1)NC(=O)…",
+                    lines=2,
                 )
+                run = gr.Button("Predict affinity", variant="primary")
                 with gr.Accordion("Advanced settings", open=False):
                     recycling = gr.Slider(
-                        1, 10, value=5, step=1, label="Recycling steps"
+                        1,
+                        8,
+                        value=DEFAULT_RECYCLING,
+                        step=1,
+                        label="Recycling steps",
+                        info="Nesso-1 was evaluated with 5. More steps = slower.",
                     )
                     seed = gr.Number(value=42, precision=0, label="Seed")
-                run = gr.Button("Predict binding affinity", variant="primary")
-            with gr.Column(scale=2):
-                out_md = gr.Markdown(label="Result")
-                out_json = gr.JSON(label="Full prediction")
+            with gr.Column(scale=1):
+                summary_out = gr.Markdown(label="Prediction")
+                binder_out = gr.Label(label="Binder classification", num_top_classes=2)
+                ligand_out = gr.Image(label="Ligand", height=260)
+                with gr.Accordion("Raw output (affinity.json)", open=False):
+                    json_out = gr.JSON(label="Nesso-1 scalars")
+
+        gr.Markdown(
+            "**Reading the output** — `affinity_pred_value` is log₁₀(IC₅₀ / µM): "
+            "**−3 ≈ 1 nM** (strong), **0 ≈ 1 µM** (moderate), **+2 ≈ 100 µM** (weak). "
+            "`entropy_crop_pl` measures confidence in the predicted protein–ligand "
+            "interface; **0.0 means the prediction should not be trusted**. "
+            "Research use only — not for clinical or diagnostic decisions."
+        )
 
         gr.Examples(
             examples=[
-                [EXAMPLE_PROTEIN, "N[C@@H](Cc1ccc(O)cc1)C(=O)O"],
-                [EXAMPLE_PROTEIN, "CCO"],
-                [EXAMPLE_PROTEIN, "Fc1ccc(cc1)C(=O)Nc1ccc(cc1)S(=O)(=O)N"],
+                [TUTORIAL_PROTEIN, "N[C@@H](Cc1ccc(O)cc1)C(=O)O"],
+                [
+                    ABL1_KINASE,
+                    "CC1=C(C=C(C=C1)NC(=O)C2=CC=C(C=C2)CN3CCN(CC3)C)NC4=NC=CC(=N4)C5=CN=CC=C5",
+                ],
+                [
+                    EGFR_KINASE,
+                    "COC1=C(C=C2C(=C1)N=CN=C2NC3=CC(=C(C=C3)F)Cl)OCCCN4CCOCC4",
+                ],
+                [
+                    CDK2,
+                    "C[C@@]12[C@@H]([C@@H](C[C@@H](O1)N3C4=CC=CC=C4C5=C6C(=C7C8=CC=CC=C8N2C7=C53)CNC6=O)NC)OC",
+                ],
+                [ABL1_KINASE, "CN1C=NC2=C1C(=O)N(C(=O)N2C)C"],
+            ],
+            example_labels=[
+                "Nesso tutorial complex + L-tyrosine",
+                "ABL1 kinase domain + imatinib",
+                "EGFR kinase domain + gefitinib",
+                "CDK2 + staurosporine",
+                "ABL1 kinase domain + caffeine (negative control)",
             ],
             inputs=[protein, ligand],
-            outputs=[out_md, out_json],
+            outputs=[ligand_out, summary_out, binder_out, json_out],
             fn=predict_affinity,
             cache_examples=True,
             cache_mode="lazy",
         )
 
     run.click(
-        predict_affinity,
+        fn=predict_affinity,
         inputs=[protein, ligand, recycling, seed],
-        outputs=[out_md, out_json],
+        outputs=[ligand_out, summary_out, binder_out, json_out],
         api_name="predict",
     )
 
-
 if __name__ == "__main__":
     demo.launch(mcp_server=True)

requirements.txt

@@ -1,14 +1 @@
-# Nesso-1 runtime deps (from its pyproject), plus the package itself with --no-deps
-# so it does not override the platform-managed gradio / spaces / huggingface_hub.
-numpy>=2.0
-lightning>=2.6.0
-rdkit>=2024.3.2
-einops>=0.8.0
-mashumaro>=3.14
-safetensors>=0.7.0
-transformers>=4.40.0
-scipy>=1.13.0
-pyyaml
-click>=8.1.7
-tqdm
-nesso @ git+https://github.com/recursionpharma/nesso.git
+nesso @ git+https://github.com/recursionpharma/nesso.git@f0156e9a22326448684bae09ee96f73415902dcd