Upload folder using huggingface_hub

README.md

@@ -6,24 +6,29 @@ colorTo: indigo
 sdk: gradio
 sdk_version: 6.20.0
 app_file: app.py
-short_description: Unified scientific model for protein, RNA, DNA, molecules
+short_description: Scientific multimodal model for RNA/DNA/protein/molecules
 python_version: "3.12"
 startup_duration_timeout: 1h
-pinned: false
 ---
 
 # Polaris-Pro — Unified Scientific Multimodal Model
 
-Interactive demo of [`sais-org/Polaris_Pro`](https://huggingface.co/sais-org/Polaris_Pro),
-an 8B scientific foundation model built on Qwen3-VL. It reasons over **proteins, RNA, DNA,
-and small molecules** through one natural-language interface:
+Interactive demo for [`sais-org/Polaris_Pro`](https://huggingface.co/sais-org/Polaris_Pro),
+an 8B foundation model that understands and generates across proteins, RNA, DNA
+and small molecules through a single natural-language interface.
 
-- RNA / DNA / protein / molecule **classification and regression**
-- **Molecule generation** from a natural-language description → SMILES
+Tasks exposed here (each uses the authors' official system prompt from
+`run_examples.sh`):
+
+- **RNA** — ncRNA family classification, translation-efficiency regression
+- **DNA** — promoter detection, enhancer-activity regression
+- **Protein** — solubility, stability, Enzyme Commission number
+- **Molecule** — Ames mutagenicity, dipole moment, text → SMILES generation
 - **Scientific text QA**
 
-Runs on ZeroGPU. Uses the authors' custom multimodal architecture (vendored under `code/`)
-and each task's benchmark system prompt.
+Weather forecasting and medical-image segmentation are part of the model but
+need gridded netCDF I/O / gated SAM-3 weights, so they are out of scope here.
 
-Weather forecasting and medical-image segmentation (which needs Meta's gated SAM 3 weights)
-are supported by the model but are out of scope for this text-interface demo.
+Built on the custom architecture from the
+[Polaris-Pro GitHub repo](https://github.com/Shanghai-Academy-of-AI-For-Science/Polaris-Pro)
+(vendored under `code/`). Runs on ZeroGPU.

app.py

@@ -1,15 +1,17 @@
 import os
+# Expandable segments guards against transient allocator fragmentation on the
+# ~23 GB checkpoint + activations.
 os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
 os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
 
 import sys
 from pathlib import Path
 
-# Vendored Polaris-Pro custom architecture lives in ./code
+# Vendored custom architecture code (qwenvl package) lives under ./code
 CODE_DIR = Path(__file__).parent / "code"
 sys.path.insert(0, str(CODE_DIR))
 
-import spaces  # noqa: E402  (must precede torch / CUDA-touching imports)
+import spaces  # noqa: E402  MUST come before torch / CUDA-touching imports
 import torch  # noqa: E402
 import gradio as gr  # noqa: E402
 from huggingface_hub import snapshot_download  # noqa: E402
@@ -19,305 +21,253 @@ from inference import BioQwen3VLInference  # noqa: E402
 MODEL_ID = "sais-org/Polaris_Pro"
 
 # ---------------------------------------------------------------------------
-# Load the model at module scope on CPU. This custom architecture's engine
-# constructor performs real CUDA initialisation (beyond the plain `.to("cuda")`
-# that ZeroGPU intercepts), which would poison the forked GPU worker
-# ("No CUDA GPUs are available"). So we build on CPU here and move the model to
-# CUDA lazily inside the first @spaces.GPU call (the worker process where real
-# CUDA is available). ~23GB bf16 weights stay in host RAM between calls.
+# Load the model once at module scope (ZeroGPU packs weights to disk here and
+# streams them to VRAM on the first @spaces.GPU call).
 # ---------------------------------------------------------------------------
-print(f"Downloading {MODEL_ID} ...")
-MODEL_PATH = snapshot_download(MODEL_ID)
-print(f"Model at {MODEL_PATH}")
-
-print("Building Polaris-Pro inference engine (CPU) ...")
-ENGINE = BioQwen3VLInference(
-    model_path=MODEL_PATH,
-    device="cpu",
+print("Downloading model weights ...")
+MODEL_DIR = snapshot_download(
+    MODEL_ID,
+    token=os.environ.get("HF_TOKEN"),
+)
+print(f"Model downloaded to {MODEL_DIR}")
+
+print("Instantiating BioQwen3VLInference (this loads ~23 GB of weights) ...")
+INFER = BioQwen3VLInference(
+    model_path=MODEL_DIR,
+    device="cuda",
     dtype=torch.bfloat16,
-    attn_impl="sdpa",              # SDPA — torch-native, works on ZeroGPU Blackwell
-    multi_gpu=False,
+    attn_impl="sdpa",              # torch-native; correct on ZeroGPU Blackwell
     fail_on_legacy_mol_decoder=False,
 )
-print("Engine ready (CPU). Model moves to CUDA on first GPU request.")
-
-_ENGINE_ON_CUDA = False
-
-
-def _ensure_cuda():
-    """Move the model onto the GPU worker's CUDA device on first use."""
-    global _ENGINE_ON_CUDA
-    if _ENGINE_ON_CUDA:
-        return
-    ENGINE.model.to("cuda")
-    ENGINE._input_device = torch.device("cuda")
-    _ENGINE_ON_CUDA = True
+print("Model ready.")
 
 
 # ---------------------------------------------------------------------------
-# Task definitions: each fixes a system prompt + how the sequence is fed.
+# Per-task presets: system prompt + prompt template + which modality field the
+# sequence input maps to. Prompts / sequences mirror run_examples.sh, which the
+# authors ship to reproduce the benchmark numbers.
 # ---------------------------------------------------------------------------
 TASKS = {
-    "RNA — ncRNA family classification": {
-        "modality": "rna",
+    "RNA · ncRNA family classification": {
+        "field": "rna",
         "system": "You are a non-coding RNA family classifier. Output only the family name, no other text.",
         "prompt": "<rna>\nWhich family does this non-coding RNA sequence belong to?",
-        "seq_label": "RNA sequence (A/U/G/C or A/C/G/T)",
-        "placeholder": "GGATGCGATCATGTCTGCACTAACACACCGGATCCCATCAGAACTCCG...",
         "task": None,
-        "max_new_tokens": 64,
+        "placeholder": "RNA / cDNA nucleotide sequence (A/C/G/U or A/C/G/T)",
     },
-    "RNA — translation efficiency (regression)": {
-        "modality": "rna",
+    "RNA · translation efficiency (regression)": {
+        "field": "rna",
         "system": None,
         "prompt": "<rna>\nWhat is the expected translation efficiency associated with the sequence?",
-        "seq_label": "RNA sequence",
-        "placeholder": "CCCCCCAAGCAACACGCGCGGGCCTATCGGCAGCACCATGGCCGCATATACCGCATATA",
         "task": None,
-        "max_new_tokens": 64,
+        "placeholder": "RNA nucleotide sequence",
     },
-    "DNA — promoter detection (Yes/No)": {
-        "modality": "dna",
-        "system": ("You are a DNA sequence analysis expert. Read the DNA sequence(s) and the "
-                   "question carefully. Respond with a single token: exactly 'Yes' or 'No'. Do not "
-                   "add any explanation, punctuation, reasoning, or additional text."),
+    "DNA · promoter detection (Yes/No)": {
+        "field": "dna",
+        "system": "You are a DNA sequence analysis expert. Read the DNA sequence(s) and the question carefully. Respond with a single token: exactly 'Yes' or 'No'. Do not add any explanation, punctuation, reasoning, or additional text.",
         "prompt": "<dna>\nIs this 300 bp DNA sequence a promoter region (all promoters, TATA and non-TATA combined)? Answer Yes or No.",
-        "seq_label": "DNA sequence",
-        "placeholder": "GCAATAAAAGGCTTAGCCACATAGTGCATGCATGTACACAGCATGTACAC",
         "task": None,
-        "max_new_tokens": 16,
+        "placeholder": "DNA nucleotide sequence (A/C/G/T)",
     },
-    "DNA — enhancer activity (regression)": {
-        "modality": "dna",
-        "system": ("You are a DNA sequence analysis expert. Read the DNA sequence and the question "
-                   "carefully. Respond with a single floating-point number only. Do not add units, "
-                   "explanations, reasoning, or any additional text."),
+    "DNA · enhancer activity (regression)": {
+        "field": "dna",
+        "system": "You are a DNA sequence analysis expert. Read the DNA sequence and the question carefully. Respond with a single floating-point number only. Do not add units, explanations, reasoning, or any additional text.",
         "prompt": "<dna>\nPredict the quantile-normalized developmental enhancer (Dev) log2 enrichment activity score of this DNA sequence. Answer with a float number.",
-        "seq_label": "DNA sequence",
-        "placeholder": "AACATACCCTGCTCTAGCGTATTGCTTTTTGGCAGCTACGTAGCTAGCTAGCTTTTCGTTTGG",
         "task": None,
-        "max_new_tokens": 32,
+        "placeholder": "DNA nucleotide sequence (A/C/G/T)",
     },
-    "Protein — solubility (0/1)": {
-        "modality": "protein",
-        "system": ("You are a protein solubility predictor. This is a binary classification task. "
-                   "Output only one digit: 1 for soluble, 0 for insoluble. Do not output any other text."),
+    "Protein · solubility (0/1)": {
+        "field": "protein",
+        "system": "You are a protein solubility predictor. This is a binary classification task. Output only one digit: 1 for soluble, 0 for insoluble. Do not output any other text.",
         "prompt": "<protein>\nSolubility prediction involves forecasting if a protein can dissolve. What is the solubility status of this protein? Output only one digit: 1 for soluble, 0 for insoluble.",
-        "seq_label": "Protein sequence (amino acids)",
-        "placeholder": "MLSVRIAAAVARALPRRAGLVSKNALGSSFIAARNFHASNTHLQKTGTAEMSSILEE...",
         "task": None,
-        "max_new_tokens": 16,
+        "placeholder": "Protein amino-acid sequence",
+    },
+    "Protein · stability (regression)": {
+        "field": "protein",
+        "system": "You are a protein stability predictor. Output only the stability score as a number, no other text.",
+        "prompt": "<protein>\nHow is the stability of this protein sequence calculated?",
+        "task": None,
+        "placeholder": "Protein amino-acid sequence",
     },
-    "Protein — Enzyme Commission (EC) number": {
-        "modality": "protein",
+    "Protein · Enzyme Commission number": {
+        "field": "protein",
         "system": "You are a protein function predictor. Output only the EC number(s), comma-separated, no other text.",
         "prompt": "<protein>\nPredict the Enzyme Commission (EC) number(s) of this protein. Output only the EC numbers, comma-separated.",
-        "seq_label": "Protein sequence (amino acids)",
-        "placeholder": "MHHHHHHSSGVDLGTENLYFQSNAMDFPQQLEACVKQANQALSRFIAPLPFQNTPVVE...",
         "task": None,
-        "max_new_tokens": 32,
+        "placeholder": "Protein amino-acid sequence",
     },
-    "Molecule — Ames mutagenicity (0/1)": {
-        "modality": "mol",
-        "system": ("You are a molecular property prediction expert; given a molecule's SMILES string "
-                   "and an ADMET endpoint description, respond with only 0 or 1 to indicate whether "
-                   "the molecule possesses that property."),
+    "Molecule · Ames mutagenicity (0/1)": {
+        "field": "mol",
+        "system": "You are a molecular property prediction expert; given a molecule's SMILES string and an ADMET endpoint description, respond with only 0 or 1 to indicate whether the molecule possesses that property.",
         "prompt": "<mol>\nGiven the SMILES representation of a molecule, predict whether it is mutagenic (1) or non-mutagenic (0) based on the Ames test.",
-        "seq_label": "Molecule SMILES",
-        "placeholder": "CC(=O)Nc1ccc2c(=O)c(=O)c3cccc4ccc1c2c43",
         "task": None,
-        "max_new_tokens": 16,
+        "placeholder": "Molecule SMILES string",
     },
-    "Molecule — dipole moment (regression)": {
-        "modality": "mol",
-        "system": ("You are a molecular property prediction expert. Based on the input molecular "
-                   "representations and instructions, answer with the specific molecular property values."),
+    "Molecule · dipole moment (regression)": {
+        "field": "mol",
+        "system": "You are a molecular property prediction expert. Based on the input molecular representations and instructions, answer with the specific molecular property values.",
         "prompt": "<mol>\nWhat is the dipole moment value of this molecular?",
-        "seq_label": "Molecule SMILES",
-        "placeholder": "CC(=O)Nc1ccccc1",
         "task": None,
-        "max_new_tokens": 32,
+        "placeholder": "Molecule SMILES string",
     },
-    "Molecule — text description → SMILES (generation)": {
-        "modality": "text",
-        "system": ("You are a molecule generation expert. Given a natural-language molecular "
-                   "description, generate one molecule as a valid canonical SMILES string. Output "
-                   "only the SMILES string, with no additional text."),
-        "prompt": None,   # user supplies the free-text description
-        "seq_label": "Molecule description (natural language)",
-        "placeholder": ("Generate a molecule that matches the following description:\n"
-                        "The molecule is a long-chain fatty acid that is henicosane in which one of the "
-                        "methyl groups has been oxidised to give the corresponding carboxylic acid.\n"
-                        "Output only the canonical SMILES string."),
+    "Molecule · text → SMILES (generation)": {
+        "field": "text",   # no bio input; description goes in the prompt
+        "system": "You are a molecule generation expert. Given a natural-language molecular description, generate one molecule as a valid canonical SMILES string. Output only the SMILES string, with no additional text.",
+        "prompt": "Generate a molecule that matches the following description:\n{input}\nOutput only the canonical SMILES string.",
         "task": "mol_generation",
-        "max_new_tokens": 128,
+        "placeholder": "Natural-language description of the molecule to generate",
     },
-    "Scientific text QA": {
-        "modality": "text",
+    "Scientific text QA (no sequence)": {
+        "field": "text",
         "system": None,
-        "prompt": None,   # user supplies the whole question
-        "seq_label": "Question / prompt",
-        "placeholder": ("The following is a multiple choice question about biology. Think step by step "
-                        "and then finish your answer with \"the answer is (X)\".\nQuestion:\nWhich molecule "
-                        "carries amino acids to the ribosome during translation?\nOptions:\nA. mRNA\nB. tRNA\n"
-                        "C. rRNA\nD. snRNA\nAnswer:"),
+        "prompt": "{input}",
         "task": None,
-        "max_new_tokens": 256,
+        "placeholder": "Ask a scientific question (multiple-choice, definitions, reasoning, ...)",
     },
 }
 
 TASK_NAMES = list(TASKS.keys())
 
 
-def _estimate_duration(task_name, user_text, max_new_tokens=None, *args, **kwargs):
-    cfg = TASKS.get(task_name, {})
-    mnt = int(max_new_tokens or cfg.get("max_new_tokens", 64))
-    # Generous fixed headroom covers the first-call CPU->CUDA move of the
-    # ~23GB model (cold worker); generation itself is fast.
-    return min(240, 120 + int(mnt * 0.5))
-
+def _duration(task_name, seq_input, max_new_tokens=64, *args, **kwargs):
+    # Generation tasks decode more tokens; bio-sequence encoding + a 23 GB
+    # model make the worst case a bit slow on a cold worker.
+    n = int(max_new_tokens or 64)
+    return min(160, 45 + int(n * 0.7))
 
-@spaces.GPU(duration=120)
-def gpu_probe() -> str:
-    """Minimal GPU probe: move model to CUDA and report the device."""
-    import torch as _t
-    _ensure_cuda()
-    x = _t.zeros(4, device="cuda")
-    return f"ok device={_t.cuda.get_device_name(0)} sum={float(x.sum().cpu())}"
 
-
-@spaces.GPU(duration=_estimate_duration)
-def run_task(task_name: str, user_text: str, max_new_tokens: int = None) -> str:
-    """Run Polaris-Pro on one scientific task.
+@spaces.GPU(duration=_duration)
+def run_inference(task_name: str, seq_input: str, max_new_tokens: int = 64) -> str:
+    """Run Polaris-Pro on one scientific input and return the model's text answer.
 
     Args:
-        task_name: which task to run (selects the fixed system prompt + input modality).
-        user_text: the sequence (RNA/DNA/protein SMILES) or free-text prompt for the task.
-        max_new_tokens: optional cap on generated tokens.
+        task_name: Which scientific task / output format to use (see the dropdown).
+        seq_input: The biological sequence (RNA/DNA/protein SMILES) or, for
+            text tasks, the natural-language question / molecule description.
+        max_new_tokens: Maximum number of tokens to generate.
 
     Returns:
-        The model's text answer (label, score, SMILES, or free-form text).
+        The model's text response (a label, score, SMILES string, or answer).
     """
-    if not user_text or not user_text.strip():
-        return "Please provide an input."
-
-    _ensure_cuda()
-    cfg = TASKS[task_name]
-    user_text = user_text.strip()
-    mnt = int(max_new_tokens) if max_new_tokens else int(cfg["max_new_tokens"])
+    if task_name not in TASKS:
+        return "Unknown task."
+    spec = TASKS[task_name]
+    seq_input = (seq_input or "").strip()
+    if not seq_input:
+        return "Please provide an input sequence / question."
+
+    field = spec["field"]
+    system = spec["system"]
+    prompt_tmpl = spec["prompt"]
+    task = spec["task"]
 
-    modality = cfg["modality"]
     kwargs = dict(
-        max_new_tokens=mnt,
-        do_sample=False,          # greedy — deterministic, matches benchmark setting
-        temperature=0.7,
-        top_p=0.9,
-        top_k=50,
-        system=cfg["system"],
+        max_new_tokens=int(max_new_tokens),
+        do_sample=False,          # greedy — matches run_examples.sh (--greedy)
+        system=system,
+        task=task,
     )
-    if cfg["task"]:
-        kwargs["task"] = cfg["task"]
-
-    if modality == "rna":
-        kwargs["rna"] = [user_text.upper()]
-        kwargs["prompt"] = cfg["prompt"]
-    elif modality == "dna":
-        kwargs["dna"] = [user_text.upper()]
-        kwargs["prompt"] = cfg["prompt"]
-    elif modality == "protein":
-        kwargs["protein"] = [user_text.upper()]
-        kwargs["prompt"] = cfg["prompt"]
-    elif modality == "mol":
-        kwargs["mol"] = [user_text]
-        kwargs["prompt"] = cfg["prompt"]
-    else:  # text (scientific QA or molecule generation from description)
-        kwargs["prompt"] = user_text
-
-    result = ENGINE.generate_from_prompt(**kwargs)
-    return result if result else "(empty response)"
+
+    if field == "text":
+        prompt = prompt_tmpl.format(input=seq_input) if "{input}" in prompt_tmpl else prompt_tmpl
+        kwargs["prompt"] = prompt
+    else:
+        # Bio-sequence task: the sequence goes to its own encoder field, and
+        # the prompt already carries the matching <rna>/<dna>/... placeholder.
+        seq = seq_input.upper() if field in ("rna", "dna", "protein") else seq_input
+        kwargs["prompt"] = prompt_tmpl
+        kwargs[field] = [seq]
+
+    out = INFER.generate_from_prompt(**kwargs)
+    return (out or "").strip() or "(empty response)"
+
+
+def on_task_change(task_name):
+    spec = TASKS.get(task_name, {})
+    return gr.update(placeholder=spec.get("placeholder", ""))
 
 
 # ---------------------------------------------------------------------------
-# UI
+# Example inputs (task_name, sequence/question, max_new_tokens) — taken from
+# the authors' run_examples.sh.
 # ---------------------------------------------------------------------------
+EXAMPLES = [
+    ["RNA · ncRNA family classification",
+     "GGATGCGATCATGTCTGCACTAACACACCGGATCCCATCAGAACTCCGAAGTTAAGCGTGCTTGGGCGGGAGTAGTACTAGGATGGGCGACCCCTTAGGAAGTACTCGTGTTGCATCCC",
+     64],
+    ["DNA · promoter detection (Yes/No)",
+     "GCAATAAAAGGCTTAGCCACATAGTGCATGCATGTACACAGCATGTACAC",
+     16],
+    ["Protein · solubility (0/1)",
+     "MLSVRIAAAVARALPRRAGLVSKNALGSSFIAARNFHASNTHLQKTGTAEMSSILEERILGADTSVDLEETGRVLSIGDGIARVHGLRNVQAEEMVEFSSGLKGMSLNLEP",
+     16],
+    ["Protein · Enzyme Commission number",
+     "MHHHHHHSSGVDLGTENLYFQSNAMDFPQQLEACVKQANQALSRFIAPLPFQNTPVVETMQYGALLGGKRLRPFLVYATGHMFGVSTNTLDAPAAAVELIHAYSLIHDDLPAMDDDDLRRGLPTCHVKFGEANAILAGDALQTLAFSILSDADLADYIIQRNK",
+     32],
+    ["Molecule · Ames mutagenicity (0/1)",
+     "CC(=O)Nc1ccc2c(=O)c(=O)c3cccc4ccc1c2c43",
+     16],
+    ["Molecule · text → SMILES (generation)",
+     "The molecule is a long-chain fatty acid that is henicosane in which one of the methyl groups has been oxidised to give the corresponding carboxylic acid. It is a straight-chain saturated fatty acid and a long-chain fatty acid.",
+     128],
+    ["Scientific text QA (no sequence)",
+     "The following is a multiple choice question about biology. Think step by step and then finish your answer with \"the answer is (X)\".\nQuestion:\nWhich molecule carries amino acids to the ribosome during translation?\nOptions:\nA. mRNA\nB. tRNA\nC. rRNA\nD. snRNA\nAnswer:",
+     256],
+]
+
 CSS = """
 #col-container { max-width: 1080px; margin: 0 auto; }
 .dark .gradio-container { color: var(--body-text-color); }
 """
 
-DESCRIPTION = """
-# 🔬 Polaris-Pro — Unified Scientific Multimodal Model
-
-[**Polaris-Pro**](https://huggingface.co/sais-org/Polaris_Pro) is an 8B scientific foundation model
-(built on Qwen3-VL) that reasons over **proteins, RNA, DNA, and small molecules** through one
-natural-language interface — classification, regression, sequence/molecule design, and scientific QA.
-
-Pick a task, paste a sequence / SMILES / question, and run. Each task uses the authors' benchmark system prompt.
-"""
+with gr.Blocks(theme=gr.themes.Citrus(), css=CSS) as demo:
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown(
+            """
+            # 🔬 Polaris-Pro — Unified Scientific Multimodal Model
 
+            [`sais-org/Polaris_Pro`](https://huggingface.co/sais-org/Polaris_Pro) is an **8B** foundation
+            model that reasons over proteins, RNA, DNA, and small molecules through a single
+            natural-language interface — no per-task fine-tuning.
 
-def _on_task_change(task_name):
-    cfg = TASKS[task_name]
-    return gr.update(label=cfg["seq_label"], placeholder=cfg["placeholder"], value="")
+            Pick a task, paste a sequence (or a question), and run. Each task uses the authors'
+            official system prompt so the output format matches their benchmarks.
 
+            *Weather forecasting and medical-image segmentation are part of the model but need
+            gridded netCDF I/O / gated SAM-3 weights, so they are out of scope for this demo.*
+            """
+        )
 
-with gr.Blocks(title="Polaris-Pro") as demo:
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(DESCRIPTION)
+        with gr.Row():
+            task = gr.Dropdown(
+                choices=TASK_NAMES, value=TASK_NAMES[0], label="Task", scale=2,
+            )
+            run = gr.Button("Run", variant="primary", scale=1)
 
-        task = gr.Dropdown(
-            choices=TASK_NAMES,
-            value=TASK_NAMES[0],
-            label="Task",
-        )
-        user_text = gr.Textbox(
-            label=TASKS[TASK_NAMES[0]]["seq_label"],
-            placeholder=TASKS[TASK_NAMES[0]]["placeholder"],
+        seq = gr.Textbox(
+            label="Input",
             lines=4,
+            placeholder=TASKS[TASK_NAMES[0]]["placeholder"],
         )
-        run_btn = gr.Button("Run", variant="primary")
-        output = gr.Textbox(label="Model output", lines=4)
+        output = gr.Textbox(label="Model response", lines=4, show_copy_button=True)
 
         with gr.Accordion("Advanced settings", open=False):
-            max_new_tokens = gr.Slider(
-                minimum=8, maximum=512, value=64, step=8,
-                label="Max new tokens",
+            max_new = gr.Slider(
+                label="Max new tokens", minimum=1, maximum=512, value=64, step=1,
             )
 
-        task.change(_on_task_change, inputs=task, outputs=user_text)
-
         gr.Examples(
-            examples=[
-                ["RNA — ncRNA family classification",
-                 "GGATGCGATCATGTCTGCACTAACACACCGGATCCCATCAGAACTCCGAAGTTAAGCGTGCTTGGGCGGGAGTAGTACTAGGATGGGCGACCCCTTAGGAAGTACTCGTGTTGCATCCC", 64],
-                ["DNA — promoter detection (Yes/No)",
-                 "GCAATAAAAGGCTTAGCCACATAGTGCATGCATGTACACAGCATGTACAC", 16],
-                ["Protein — solubility (0/1)",
-                 "MLSVRIAAAVARALPRRAGLVSKNALGSSFIAARNFHASNTHLQKTGTAEMSSILEERILGADTSVDLEETGRVLSIGDGIARVHGLRNVQAEEMVEFSSGLKGMSLNLEP", 16],
-                ["Molecule — Ames mutagenicity (0/1)",
-                 "CC(=O)Nc1ccc2c(=O)c(=O)c3cccc4ccc1c2c43", 16],
-                ["Molecule — text description → SMILES (generation)",
-                 "Generate a molecule that matches the following description:\nThe molecule is a long-chain fatty acid that is henicosane in which one of the methyl groups has been oxidised to give the corresponding carboxylic acid.\nOutput only the canonical SMILES string.", 128],
-                ["Scientific text QA",
-                 "The following is a multiple choice question about biology. Think step by step and then finish your answer with \"the answer is (X)\".\nQuestion:\nWhich molecule carries amino acids to the ribosome during translation?\nOptions:\nA. mRNA\nB. tRNA\nC. rRNA\nD. snRNA\nAnswer:", 256],
-            ],
-            inputs=[task, user_text, max_new_tokens],
+            examples=EXAMPLES,
+            inputs=[task, seq, max_new],
             outputs=output,
-            fn=run_task,
+            fn=run_inference,
             cache_examples=False,
             run_on_click=True,
         )
 
-    run_btn.click(
-        run_task,
-        inputs=[task, user_text, max_new_tokens],
-        outputs=output,
-        api_name="run_task",
-    )
-
-    probe_btn = gr.Button("probe", visible=False)
-    probe_btn.click(gpu_probe, inputs=None, outputs=output, api_name="gpu_probe")
-
+    task.change(on_task_change, inputs=task, outputs=seq)
+    run.click(run_inference, inputs=[task, seq, max_new], outputs=output, api_name="generate")
 
 if __name__ == "__main__":
-    demo.queue(max_size=10).launch(theme=gr.themes.Citrus(), css=CSS, mcp_server=True)
+    demo.launch(mcp_server=True)

requirements.txt

@@ -1,21 +1,22 @@
-# torchvision is required by transformers 5.0.0's video-processor auto-loader
-# (Qwen3VLProcessor pulls in Qwen3VLVideoProcessor); without it processor
-# loading crashes with "argument of type 'NoneType' is not iterable".
-# Left unpinned so it matches the ZeroGPU-preinstalled torch.
-torchvision
-# transformers 5.0.0 provides the qwen3_vl arch + Sam3Model used by Polaris-Pro.
-# Upstream pins this exactly for correctness; keep pinned.
+# Polaris-Pro scientific multimodal model — ZeroGPU inference deps.
+# torch / gradio / spaces / huggingface_hub are provided by the runtime and
+# must NOT be pinned here.
+
+# Transformers stack — transformers 5.0.0 provides the qwen3_vl arch + Sam3
+# used by the custom Polaris-Pro architecture. Pin is required for correctness.
 transformers==5.0.0
-accelerate
+tokenizers==0.22.2
+accelerate==1.7.0
 safetensors
-sentencepiece
+
 # Numerics
 numpy
 scipy
 einops
-# Molecule modality: RDKit (SMILES<->graph) + PyTorch-Geometric (GNN encoder)
+
+# Molecule modality: RDKit (SMILES -> graph) + PyTorch-Geometric (GNN encoder)
 rdkit
 torch-geometric
-# Image ops (med_seg processor import path)
+
+# Image ops used by some modality processors
 opencv-python-headless
-pillow