Upload folder using huggingface_hub

README.md

@@ -1,13 +1,28 @@
 ---
-title: Nesso
-emoji: ⚡
+title: Nesso-1 Binding Affinity
+emoji: 🧬
 colorFrom: gray
-colorTo: indigo
+colorTo: purple
 sdk: gradio
-sdk_version: 6.22.0
-python_version: '3.12'
+sdk_version: 5.49.1
 app_file: app.py
+short_description: Fast protein-ligand binding affinity prediction (Nesso-1)
+python_version: "3.12"
+startup_duration_timeout: 1h
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Nesso-1 · Protein–Ligand Binding Affinity
+
+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).
+
+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.
+
+- Model card: https://huggingface.co/recursionpharma/nesso
+- Code: https://github.com/recursionpharma/nesso
+- License: Apache-2.0
+
+Example inputs are taken from the Nesso-1 tutorial in the official repository.

app.py

@@ -0,0 +1,239 @@
+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")
+
+import spaces  # noqa: E402  — must precede torch / CUDA-touching imports
+
+import json  # 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"
+)
+
+
+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"}}],
+    }
+    return pyyaml.safe_dump(doc, sort_keys=False)
+
+
+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
+
+    args = [
+        "predict",
+        str(yaml_path),
+        "--out_dir",
+        str(out_dir),
+        "--accelerator",
+        "gpu",
+        "--recycling_steps",
+        str(int(recycling_steps)),
+        "--seed",
+        str(int(seed)),
+    ]
+    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
+
+
+@spaces.GPU(duration=180)
+def predict_affinity(
+    protein_seq: str,
+    ligand_smiles: str,
+    recycling_steps: int = 5,
+    seed: int = 42,
+    progress=gr.Progress(track_tqdm=True),
+):
+    """Predict protein–ligand binding affinity with Nesso-1.
+
+    Args:
+        protein_seq: Target protein amino-acid sequence (single-letter codes).
+        ligand_smiles: Ligand as a SMILES string.
+        recycling_steps: Number of trunk recycling iterations (higher = more compute).
+        seed: Random seed for reproducibility.
+
+    Returns:
+        A markdown summary of the predicted binding affinity and binder probability,
+        and the full raw prediction JSON.
+    """
+    protein_seq = (protein_seq or "").strip().replace("\n", "").replace(" ", "")
+    ligand_smiles = (ligand_smiles or "").strip()
+    if not protein_seq:
+        raise gr.Error("Please provide a protein amino-acid sequence.")
+    if not ligand_smiles:
+        raise gr.Error("Please provide a ligand SMILES string.")
+
+    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:]}"
+        )
+
+    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 |
+|---|---|
+| **Binding affinity** (log₁₀ IC₅₀/µM) | `{aff:.3f}` |
+| **Estimated IC₅₀** | **{_ic50_str(aff)}** |
+| **Binder probability** | `{prob:.3f}` |
+| **Interpretation** | {strength} |
+
+_Lower affinity ⇒ stronger binding. Computed in {elapsed:.1f}s._
+"""
+    return summary, data
+
+
+CSS = """
+#col-container { max-width: 1000px; 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.Column(elem_id="col-container"):
+        gr.Markdown(DESCRIPTION)
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                protein = gr.Textbox(
+                    label="Protein sequence",
+                    placeholder="MKTAYIAKQ... (single-letter amino-acid codes)",
+                    lines=5,
+                )
+                ligand = gr.Textbox(
+                    label="Ligand SMILES",
+                    placeholder="e.g. N[C@@H](Cc1ccc(O)cc1)C(=O)O",
+                    lines=1,
+                )
+                with gr.Accordion("Advanced settings", open=False):
+                    recycling = gr.Slider(
+                        1, 10, value=5, step=1, label="Recycling steps"
+                    )
+                    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")
+
+        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"],
+            ],
+            inputs=[protein, ligand],
+            outputs=[out_md, out_json],
+            fn=predict_affinity,
+            cache_examples=True,
+            cache_mode="lazy",
+        )
+
+    run.click(
+        predict_affinity,
+        inputs=[protein, ligand, recycling, seed],
+        outputs=[out_md, out_json],
+        api_name="predict",
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

requirements.txt

@@ -0,0 +1,14 @@
+# 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