Use Pharmpy VPCs and seed 42

README.md

@@ -27,7 +27,9 @@ does not consume visitors' daily GPU quota.
 Public requests generate 20 individuals by default and are capped at 30
 individuals. The demo fixes flow integration to eight Heun steps; solver
 controls are not exposed. These limits are enforced by both the dashboard and
-the inference service.
+the inference service. Pharmpy computes each displayed VPC from that same
+generated pool using design-matched resampled cohorts and equal-number time
+bins.
 
 The named Gradio endpoints are `/health` and `/inference`. Inference is
 serialized to keep memory use bounded; identical requests reuse a response

requirements.txt

@@ -2,5 +2,7 @@ gradio>=6,<7
 huggingface-hub>=1.0,<2
 lightning>=2.6,<2.7
 numpy>=1.26,<3
+pandas>=2.2,<4
+pharmpy-core>=2.1,<2.2
 pyyaml>=6,<7
 torch==2.8.0

services/inference/pff_service.py

@@ -37,6 +37,11 @@ from pff_pk.inference.empirical import (  # noqa: E402
 )
 from pff_pk.inference.model import load_inference_model  # noqa: E402
 
+try:  # module import in tests and the hosted Space
+    from services.inference.pharmpy_vpc import pharmpy_vpc_summary  # noqa: E402
+except ModuleNotFoundError:  # direct execution from services/inference
+    from pharmpy_vpc import pharmpy_vpc_summary  # type: ignore[no-redef]  # noqa: E402
+
 DEFAULT_CONFIG = PFF_ROOT / "configs" / "amarel_v6_protocol_counterfactual_phase2_sparse.yaml"
 DEFAULT_CHECKPOINT = (
     PFF_ROOT / "artifacts" / "checkpoints" / "lucid_marten_v6_step750"
@@ -58,6 +63,9 @@ DEFAULT_GENERATED_INDIVIDUALS = 20
 MAX_GENERATED_INDIVIDUALS = 30
 DEFAULT_FLOW_STEPS = 8
 MAX_FLOW_STEPS = 16
+VPC_REPLICATES = 200
+VPC_REQUESTED_BINS = 10
+VPC_SEED_OFFSET = 104729
 PYTHIA_MODEL = "pythia"
 PYTHIA_DOSE_MODEL = "pythia_dose"
 DEFAULT_MODEL = PYTHIA_DOSE_MODEL
@@ -317,7 +325,7 @@ class ModelRuntime:
         )
         cpu_batch = union_query_batch(cpu_batch)
         query_time = cpu_batch.target_time.numpy()[0, :, 0] * cohort["horizon"]
-        seed = bounded_integer(request.get("seed", 161803), "seed", 0, 2**31 - 1)
+        seed = bounded_integer(request.get("seed", 42), "seed", 0, 2**31 - 1)
         started = time.perf_counter()
         chunks = []
         for start in range(0, n_draws, batch_size):
@@ -334,6 +342,14 @@ class ModelRuntime:
                 physical = inverse_concentration(normalized, repeated).float().cpu().numpy()
             chunks.append(physical[..., 0])
         samples = np.concatenate(chunks, axis=0)
+        vpc = pharmpy_vpc_summary(
+            samples,
+            query_time,
+            cohort,
+            replicates=VPC_REPLICATES,
+            requested_bins=VPC_REQUESTED_BINS,
+            seed=seed + VPC_SEED_OFFSET,
+        )
         elapsed = time.perf_counter() - started
         return {
             "inferenceId": "",
@@ -349,6 +365,7 @@ class ModelRuntime:
             },
             "queryTime": query_time.tolist(),
             "generatedConcentration": samples.tolist(),
+            "vpc": vpc,
             "units": {"time": cohort["time_units"], "concentration": cohort["concentration_units"]},
             "provenance": {
                 "checkpointSha256": self.checkpoint_sha256,
@@ -423,7 +440,7 @@ def cached_inference(request: dict[str, Any]) -> dict[str, Any]:
     runtime = runtime_for_request(request)
     runtime.load()
     cache_key = {
-        "schemaVersion": 1,
+        "schemaVersion": 2,
         "request": request,
         "checkpointSha256": runtime.checkpoint_sha256,
         "configSha256": hashlib.sha256(runtime.config_path.read_bytes()).hexdigest(),

services/inference/pharmpy_vpc.py

@@ -0,0 +1,196 @@
+"""Design-matched Pharmpy VPC summaries for interactive inference."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from pharmpy.modeling import (
+    bin_observations,
+    create_basic_pk_model,
+    plot_vpc,
+    set_dataset,
+)
+
+
+def _effective_bins(model, requested: int) -> int:
+    unique_times = int(model.dataset["TIME"].nunique())
+    for candidate in range(min(requested, unique_times), 0, -1):
+        membership, boundaries = bin_observations(model, "equal_number", candidate)
+        if (
+            membership.notna().all()
+            and membership.nunique() == candidate
+            and len(boundaries) == candidate + 1
+            and np.all(np.diff(boundaries) > 0.0)
+        ):
+            return candidate
+    raise ValueError("Pharmpy could not construct non-empty VPC bins")
+
+
+def _statistics_frame(
+    observed: pd.DataFrame,
+    simulations: pd.DataFrame,
+    *,
+    requested_bins: int,
+) -> tuple[pd.DataFrame, int]:
+    model = set_dataset(create_basic_pk_model("iv"), observed, datatype="nonmem")
+    bins = _effective_bins(model, requested_bins)
+    chart = plot_vpc(
+        model,
+        simulations,
+        binning="equal_number",
+        nbins=bins,
+        qi=0.90,
+        ci=0.90,
+    )
+    required = {
+        "obs_central",
+        "obs_lower",
+        "obs_upper",
+        "sim_central",
+        "sim_central_lower",
+        "sim_central_upper",
+        "sim_lower",
+        "sim_lower_lower",
+        "sim_lower_upper",
+        "sim_upper",
+        "sim_upper_lower",
+        "sim_upper_upper",
+        "bin_midpoint",
+        "bin_edges_left",
+        "bin_edges_right",
+        "n_data_points",
+    }
+    for layer in chart.layer:
+        data = getattr(layer, "data", None)
+        if isinstance(data, pd.DataFrame) and required <= set(data.columns):
+            return data.reset_index(drop=True).copy(), bins
+    raise RuntimeError("Pharmpy VPC did not expose its statistics table")
+
+
+def _finite_float(value: Any, label: str) -> float:
+    result = float(value)
+    if not np.isfinite(result):
+        raise ValueError(f"non-finite {label} in Pharmpy VPC output")
+    return result
+
+
+def pharmpy_vpc_summary(
+    generated_concentration: np.ndarray,
+    query_time: np.ndarray,
+    cohort: dict[str, Any],
+    *,
+    replicates: int = 200,
+    requested_bins: int = 10,
+    seed: int = 42,
+) -> dict[str, Any]:
+    """Compute a formal VPC from one finite pool of generated individuals.
+
+    The neural model is evaluated only for the rows in ``generated_concentration``.
+    Each inexpensive simulation replicate then samples one generated curve for each
+    empirical individual and evaluates it on that individual's observation schedule.
+    Pharmpy owns equal-number binning and all observed/simulated quantiles.
+    """
+    pool = np.asarray(generated_concentration, dtype=np.float64)
+    times = np.asarray(query_time, dtype=np.float64)
+    if pool.ndim != 2 or times.ndim != 1 or pool.shape[1] != len(times):
+        raise ValueError("generated pool and query mesh are misaligned")
+    if not len(pool) or not len(times) or not np.isfinite(pool).all() or not np.isfinite(times).all():
+        raise ValueError("generated pool and query mesh must be finite and non-empty")
+    if np.any(pool <= 0.0) or np.any(np.diff(times) <= 0.0):
+        raise ValueError("Pharmpy VPC requires positive concentrations and increasing times")
+    if replicates < 20:
+        raise ValueError("Pharmpy VPC requires at least 20 resampled cohort replicates")
+    if requested_bins < 1:
+        raise ValueError("requested VPC bins must be positive")
+
+    observed_rows: list[dict[str, float | int]] = []
+    schedules: list[np.ndarray] = []
+    tolerance = max(float(cohort["horizon"]) * 2.0e-6, 1.0e-9)
+    for individual, curve in enumerate(cohort["subjects"].values(), start=1):
+        schedule = np.asarray([point[0] for point in curve], dtype=np.float64)
+        values = np.asarray([point[1] for point in curve], dtype=np.float64)
+        indices = np.abs(times[:, None] - schedule[None, :]).argmin(axis=0)
+        if len(schedule) and np.max(np.abs(times[indices] - schedule)) > tolerance:
+            raise ValueError("an empirical observation time is absent from the query mesh")
+        schedules.append(indices)
+        observed_rows.extend(
+            {
+                "ID": individual,
+                "TIME": float(time),
+                "DV": float(value),
+                "MDV": 0,
+                "AMT": 0.0,
+            }
+            for time, value in zip(schedule, values, strict=True)
+        )
+
+    observed = pd.DataFrame(observed_rows)
+    observed.index = np.arange(1, len(observed) + 1)
+    rng = np.random.default_rng(seed)
+    simulation_values = np.empty((replicates, len(observed)), dtype=np.float64)
+    for replicate in range(replicates):
+        selected = rng.choice(
+            len(pool),
+            size=len(schedules),
+            replace=len(pool) < len(schedules),
+        )
+        cursor = 0
+        for draw, indices in zip(selected, schedules, strict=True):
+            count = len(indices)
+            simulation_values[replicate, cursor : cursor + count] = pool[draw, indices]
+            cursor += count
+    simulations = pd.DataFrame(
+        {
+            "SIM": np.repeat(np.arange(1, replicates + 1), len(observed)),
+            "index": np.tile(np.arange(1, len(observed) + 1), replicates),
+            "DV": simulation_values.reshape(-1),
+        }
+    ).set_index(["SIM", "index"])
+    statistics, bins = _statistics_frame(
+        observed,
+        simulations,
+        requested_bins=requested_bins,
+    )
+
+    points = []
+    for row in statistics.to_dict(orient="records"):
+        points.append(
+            {
+                "time": _finite_float(row["bin_midpoint"], "bin midpoint"),
+                "timeLower": _finite_float(row["bin_edges_left"], "left bin edge"),
+                "timeUpper": _finite_float(row["bin_edges_right"], "right bin edge"),
+                "nObservations": int(row["n_data_points"]),
+                "observed": {
+                    "q05": _finite_float(row["obs_lower"], "observed lower quantile"),
+                    "q50": _finite_float(row["obs_central"], "observed median"),
+                    "q95": _finite_float(row["obs_upper"], "observed upper quantile"),
+                },
+                "simulated": {
+                    "q05": {
+                        "center": _finite_float(row["sim_lower"], "simulated lower quantile"),
+                        "lower": _finite_float(row["sim_lower_lower"], "lower-quantile interval"),
+                        "upper": _finite_float(row["sim_lower_upper"], "lower-quantile interval"),
+                    },
+                    "q50": {
+                        "center": _finite_float(row["sim_central"], "simulated median"),
+                        "lower": _finite_float(row["sim_central_lower"], "median interval"),
+                        "upper": _finite_float(row["sim_central_upper"], "median interval"),
+                    },
+                    "q95": {
+                        "center": _finite_float(row["sim_upper"], "simulated upper quantile"),
+                        "lower": _finite_float(row["sim_upper_lower"], "upper-quantile interval"),
+                        "upper": _finite_float(row["sim_upper_upper"], "upper-quantile interval"),
+                    },
+                },
+            }
+        )
+    return {
+        "method": "pharmpy",
+        "generatedIndividuals": int(len(pool)),
+        "simulatedCohortReplicates": int(replicates),
+        "requestedBins": int(requested_bins),
+        "effectiveBins": int(bins),
+        "points": points,
+    }