workbench 0.8.331__py3-none-any.whl → 0.8.332__py3-none-any.whl

workbench/algorithms/dataframe/__init__.py

@@ -10,7 +10,7 @@ from .feature_space_proximity import FeatureSpaceProximity
 from .fingerprint_proximity import FingerprintProximity
 from .projection_2d import Projection2D
 from .smart_aggregator import smart_aggregator
-from .dataset_comparison import DatasetComparison
+from .multi_task_alignment import MultiTaskAlignment
 
 __all__ = [
     "Proximity",
@@ -18,5 +18,5 @@ __all__ = [
     "FingerprintProximity",
     "Projection2D",
     "smart_aggregator",
-    "DatasetComparison",
+    "MultiTaskAlignment",
 ]

workbench/algorithms/dataframe/multi_task_alignment.py

@@ -0,0 +1,443 @@
+"""Multi-task alignment: chemical-space coverage and per-aux concordance against a primary target.
+
+Driver: deciding whether a multi-task chemprop run (e.g. ``mdr1_er + caco2_er + caco2_pappab + logd``
+auxiliaries) will lift over a single-task model on the primary. Two ingredients matter:
+
+    1. **Chemical-space coverage** — do auxiliary compounds occupy the same chemistry as the
+       primary? Strong coverage means the aux head's gradient on shared chemistry can refine
+       the encoder. Aux-only chemistry that's well-connected to primary extends coverage.
+    2. **Per-aux alignment** — where they overlap, do the targets agree (Pearson r) and do
+       the local SAR neighborhoods predict each other (z-scored residual)?
+
+Build one shared ``FingerprintProximity`` (ECFP + KNN + UMAP) on the union of all rows that
+have any target value, then per aux compute label-only stats (counts, Pearson r, recommendation)
+and chemistry stats (Tanimoto coverage, z-scored residual).
+
+For the matching UI / "map" view, see
+``workbench.web_interface.components.plugins.MultiTaskAlignmentMap``.
+"""
+
+import logging
+from typing import Optional, Union
+
+import numpy as np
+import pandas as pd
+
+from workbench.algorithms.dataframe.fingerprint_proximity import FingerprintProximity
+
+log = logging.getLogger("workbench")
+
+
+class MultiTaskAlignment:
+    """Per-aux alignment of a multi-task DataFrame against a primary target.
+
+    Input is a wide multi-task DataFrame: one row per compound, with ``id_column``,
+    ``smiles``, the primary target column, and one or more auxiliary target columns.
+    Targets are NaN where not measured.
+
+    A single ``FingerprintProximity`` is built on the union of all rows that have any
+    target value, so every per-aux computation reuses the same fingerprints, KNN graph,
+    and UMAP coordinates.
+
+    Use ``summary()`` for the per-aux quantitative table, ``results()`` for the
+    per-compound DataFrame (with shared UMAP coords + per-aux ``tanimoto_to_primary_<aux>``
+    and ``residual_<aux>`` columns), and ``neighbors()`` for compound-level lookups.
+    """
+
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        primary: str,
+        auxiliaries: Optional[list[str]] = None,
+        id_column: str = "id",
+        k_neighbors: int = 5,
+        radius: int = 2,
+        n_bits: int = 2048,
+        min_n_shared: int = 10,
+        extension_ratio_threshold: float = 0.5,
+    ) -> None:
+        """Initialize the alignment and run all per-aux computations.
+
+        Args:
+            df: Wide multi-task DataFrame with ``id_column``, ``smiles``, ``primary``,
+                and aux target columns. NaN means the target wasn't measured.
+            primary: Name of the primary target column.
+            auxiliaries: Aux target column names. If None, defaults to every numeric
+                column that isn't ``id_column``, ``smiles``, or ``primary``.
+            id_column: Identifier column name (default: ``"id"``).
+            k_neighbors: Number of primary-having neighbors used for the residual
+                computation (default: 5).
+            radius: Morgan fingerprint radius (default: 2 = ECFP4).
+            n_bits: Number of fingerprint bits (default: 2048).
+            min_n_shared: Minimum rows-with-both-targets before Pearson r is trusted
+                (default: 10).
+            extension_ratio_threshold: ``n_aux_only / n_primary`` above which the
+                extension region counts as "substantial volume" (default: 0.5).
+        """
+        for col in (id_column, "smiles", primary):
+            if col not in df.columns:
+                raise ValueError(f"DataFrame missing required column: {col!r}")
+
+        if auxiliaries is None:
+            reserved = {id_column, "smiles", primary}
+            auxiliaries = [c for c in df.columns if c not in reserved and pd.api.types.is_numeric_dtype(df[c])]
+        else:
+            for aux in auxiliaries:
+                if aux not in df.columns:
+                    raise ValueError(f"Aux column {aux!r} not in DataFrame")
+                if aux == primary:
+                    raise ValueError(f"Aux {aux!r} is the same as primary")
+
+        if not auxiliaries:
+            raise ValueError("No auxiliaries provided and none auto-detected from numeric columns")
+
+        self.id_column = id_column
+        self.primary = primary
+        self.auxiliaries = list(auxiliaries)
+        self.k_neighbors = k_neighbors
+        self.min_n_shared = min_n_shared
+        self.extension_ratio_threshold = extension_ratio_threshold
+
+        all_targets = [primary, *self.auxiliaries]
+
+        # Drop rows with no target values at all — they can't contribute
+        any_target = df[all_targets].notna().any(axis=1)
+        n_dropped = int((~any_target).sum())
+        if n_dropped:
+            log.info(f"Dropping {n_dropped} rows with no target values")
+        df = df.loc[any_target].copy()
+
+        dup_mask = df.duplicated(subset=id_column, keep="first")
+        if dup_mask.any():
+            log.warning(f"Dropping {dup_mask.sum()} duplicate {id_column!r} value(s) (keeping first)")
+            df = df.loc[~dup_mask].copy()
+
+        log.info(f"MultiTaskAlignment: {len(df)} compounds, primary={primary!r}, " f"auxiliaries={self.auxiliaries}")
+
+        self._prox = FingerprintProximity(
+            df,
+            id_column=id_column,
+            target=None,
+            include_all_columns=True,
+            radius=radius,
+            n_bits=n_bits,
+        )
+
+        log.info("Computing per-compound alignment metrics...")
+        self._per_compound = self._compute_per_compound()
+        self._summary = self._compute_summary()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def results(self) -> pd.DataFrame:
+        """Per-compound DataFrame with shared UMAP coords and per-aux alignment columns.
+
+        Returns:
+            DataFrame with original columns (``id``, ``smiles``, primary, all auxes), plus:
+                - ``x``, ``y``: shared UMAP 2D coordinates
+                - ``tanimoto_to_primary``: best Tanimoto similarity from this row to any
+                  primary-having row (1.0 for primary rows themselves)
+                - ``residual_<aux>``: z-scored residual for each aux, defined only on
+                  rows where the aux is measured. Computed as
+                  ``z(aux) - median(z(primary)`` over top-k primary-having neighbors``)``.
+                  Sign indicates direction of disagreement; magnitude is in std units.
+        """
+        df = self._prox.df.copy()
+        internal_cols = [
+            "nn_distance",
+            "nn_id",
+            "nn_target",
+            "nn_target_diff",
+            "nn_similarity",
+            "fingerprint",
+        ]
+        df = df.drop(columns=[c for c in internal_cols if c in df.columns])
+        df = df.merge(self._per_compound, on=self.id_column, how="left")
+        return df
+
+    def summary(self) -> pd.DataFrame:
+        """Per-aux quantitative summary, one row per aux.
+
+        Returns:
+            DataFrame with columns:
+                - ``aux``: aux target name
+                - ``n_primary``, ``n_aux``, ``n_shared``, ``n_aux_only``: row counts
+                - ``pearson_r``: correlation on shared rows (NaN if ``n_shared < min_n_shared``)
+                - ``r_confidence``: ``high`` / ``moderate`` / ``low`` / ``unmeasured``
+                - ``tanimoto_coverage_mean``: mean Tanimoto from aux-having rows to nearest
+                  primary-having row
+                - ``frac_coverage_ge_05``, ``frac_coverage_ge_03``: fraction of aux-having
+                  rows with Tanimoto coverage above the threshold
+                - ``residual_abs_mean``, ``residual_abs_p95``: z-scored residual stats over
+                  aux-having rows that have at least one primary neighbor
+                - ``overlap``: ``Beneficial`` / ``Neutral`` / ``Harmful`` / ``N/A``
+                - ``extension``: ``Strong`` / ``Modest`` / ``Minimal`` / ``None``
+                - ``recommendation``: ``Use`` / ``Marginal`` / ``Risky`` / ``Skip``
+        """
+        return self._summary.copy()
+
+    def neighbors(
+        self,
+        compound_id: Union[str, int, list],
+        n_neighbors: int = 10,
+    ) -> pd.DataFrame:
+        """Nearest neighbors for a compound (or list) in the shared fingerprint space.
+
+        Args:
+            compound_id: ID or list of IDs to look up.
+            n_neighbors: Number of neighbors to return (default: 10).
+
+        Returns:
+            DataFrame sorted by similarity (descending) with the query id, ``neighbor_id``,
+            ``similarity``, ``smiles``, and the primary + aux target columns.
+        """
+        nbrs = self._prox.neighbors(compound_id, n_neighbors=n_neighbors)
+        keep = [self.id_column, "neighbor_id", "similarity", "smiles", self.primary, *self.auxiliaries]
+        return nbrs[[c for c in keep if c in nbrs.columns]].reset_index(drop=True)
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+
+    def _compute_per_compound(self) -> pd.DataFrame:
+        """Per-row chemistry signals: Tanimoto coverage and z-scored residual per aux."""
+        df = self._prox.df
+        all_ids = df[self.id_column].tolist()
+        primary_mask = df[self.primary].notna()
+        primary_ids = set(df.loc[primary_mask, self.id_column])
+
+        # One bulk neighbor lookup; we'll filter to primary-having neighbors below
+        n_lookup = max(50, self.k_neighbors * 10)
+        nbrs = self._prox.neighbors(all_ids, n_neighbors=n_lookup)
+
+        # Drop self-neighbors so a primary row's own value doesn't satisfy its coverage
+        nbrs_no_self = nbrs[nbrs[self.id_column] != nbrs["neighbor_id"]].copy()
+        primary_nbrs = nbrs_no_self[nbrs_no_self["neighbor_id"].isin(primary_ids)].copy()
+
+        # Tanimoto-to-primary: best similarity to any primary-having compound
+        best_sim = primary_nbrs.groupby(self.id_column)["similarity"].max()
+
+        result = pd.DataFrame({self.id_column: all_ids})
+        result["tanimoto_to_primary"] = result[self.id_column].map(best_sim).fillna(0.0)
+        # Primary rows are by definition fully covered
+        result.loc[result[self.id_column].isin(primary_ids), "tanimoto_to_primary"] = 1.0
+
+        # Z-scored "predicted primary" from top-k primary-having neighbors
+        primary_nbrs = primary_nbrs.sort_values([self.id_column, "similarity"], ascending=[True, False])
+        primary_nbrs["_rank"] = primary_nbrs.groupby(self.id_column).cumcount() + 1
+        topk = primary_nbrs[primary_nbrs["_rank"] <= self.k_neighbors].copy()
+
+        primary_vals = df.set_index(self.id_column)[self.primary]
+        primary_z = self._zscore(primary_vals)
+        topk["primary_z"] = topk["neighbor_id"].map(primary_z)
+        primary_z_pred = topk.groupby(self.id_column)["primary_z"].median()
+
+        # Per-aux z-scored residual: defined only where the aux is measured
+        for aux in self.auxiliaries:
+            aux_vals = df.set_index(self.id_column)[aux]
+            aux_z = self._zscore(aux_vals)
+            aux_z_aligned = result[self.id_column].map(aux_z)
+            primary_pred_aligned = result[self.id_column].map(primary_z_pred)
+            residual = aux_z_aligned - primary_pred_aligned
+            # Mask rows that don't have the aux value
+            aux_present = result[self.id_column].map(aux_vals.notna()).fillna(False).values
+            result[f"residual_{aux}"] = np.where(aux_present, residual.values, np.nan)
+
+        return result
+
+    def _compute_summary(self) -> pd.DataFrame:
+        """Per-aux quantitative summary (counts, pearson, coverage, residuals, verdicts)."""
+        df = self._prox.df
+        primary_mask = df[self.primary].notna()
+        n_primary = int(primary_mask.sum())
+        rows = []
+
+        for aux in self.auxiliaries:
+            aux_mask = df[aux].notna()
+            n_aux = int(aux_mask.sum())
+            n_shared = int((primary_mask & aux_mask).sum())
+            n_aux_only = int((~primary_mask & aux_mask).sum())
+
+            if n_shared >= self.min_n_shared:
+                pearson_r = float(df.loc[primary_mask & aux_mask, [self.primary, aux]].corr().iloc[0, 1])
+            else:
+                pearson_r = float("nan")
+
+            aux_ids = df.loc[aux_mask, self.id_column]
+            cov = self._per_compound.set_index(self.id_column).loc[aux_ids, "tanimoto_to_primary"]
+            cov_mean = float(cov.mean()) if len(cov) else 0.0
+            cov_05 = float((cov >= 0.5).mean()) if len(cov) else 0.0
+            cov_03 = float((cov >= 0.3).mean()) if len(cov) else 0.0
+
+            residuals = self._per_compound[f"residual_{aux}"].dropna()
+            res_abs_mean = float(residuals.abs().mean()) if len(residuals) else float("nan")
+            res_abs_p95 = float(residuals.abs().quantile(0.95)) if len(residuals) else float("nan")
+
+            overlap, _ = _assess_overlap(pearson_r, n_shared, self.min_n_shared)
+            extension, _ = _assess_extension(pearson_r, n_aux_only, n_primary, self.extension_ratio_threshold)
+            recommendation, _ = _combine_assessments(overlap, extension)
+
+            rows.append(
+                {
+                    "aux": aux,
+                    "n_primary": n_primary,
+                    "n_aux": n_aux,
+                    "n_shared": n_shared,
+                    "n_aux_only": n_aux_only,
+                    "pearson_r": pearson_r,
+                    "r_confidence": _confidence_tier(n_shared, self.min_n_shared),
+                    "tanimoto_coverage_mean": cov_mean,
+                    "frac_coverage_ge_05": cov_05,
+                    "frac_coverage_ge_03": cov_03,
+                    "residual_abs_mean": res_abs_mean,
+                    "residual_abs_p95": res_abs_p95,
+                    "overlap": overlap,
+                    "extension": extension,
+                    "recommendation": recommendation,
+                }
+            )
+            r_str = f"r={pearson_r:.3f}" if not np.isnan(pearson_r) else "r=NA"
+            log.info(
+                f"  {aux}: shared={n_shared:,} aux_only={n_aux_only:,} {r_str} "
+                f"cov_mean={cov_mean:.2f} -> overlap={overlap}, extension={extension} "
+                f"-> {recommendation}"
+            )
+
+        return pd.DataFrame(rows)
+
+    @staticmethod
+    def _zscore(s: pd.Series) -> pd.Series:
+        """Z-score a Series; returns zeros if std is zero (constant column)."""
+        std = s.std(ddof=0)
+        if not np.isfinite(std) or std == 0:
+            return s - s.mean()
+        return (s - s.mean()) / std
+
+
+# ----------------------------------------------------------------------
+# Verdict helpers (label-only scoring; same thresholds across multi-task code)
+# ----------------------------------------------------------------------
+
+
+def _confidence_tier(n_shared: int, min_n_shared: int) -> str:
+    """Bucket how trustworthy a Pearson r is, given shared-compound count."""
+    if n_shared < min_n_shared:
+        return "unmeasured"
+    if n_shared < 30:
+        return "low"
+    if n_shared < 100:
+        return "moderate"
+    return "high"
+
+
+def _assess_overlap(r: float, n_shared: int, min_n_shared: int) -> tuple[str, str]:
+    """Score the overlap region (compounds with both primary and aux measured).
+
+    Thresholds (label-correlation on shared rows):
+        r in [0.4, 0.95]  -> Beneficial : sweet spot — heads predict related but distinct targets
+        r > 0.95          -> Neutral    : redundant; aux head just re-weights primary
+        r < 0.4           -> Harmful    : discordant; gradient conflict / negative-transfer risk
+        n_shared too low  -> N/A
+    """
+    if n_shared < min_n_shared:
+        return ("N/A", f"only {n_shared} shared compounds (need >= {min_n_shared} to score)")
+    if 0.4 <= r <= 0.95:
+        return (
+            "Beneficial",
+            f"sweet-spot r={r:.2f} on {n_shared:,} shared compounds — encoder learns richer features",
+        )
+    if r > 0.95:
+        return (
+            "Neutral",
+            f"redundant r={r:.2f} on {n_shared:,} shared compounds — aux head just re-weights primary",
+        )
+    return (
+        "Harmful",
+        f"discordant r={r:.2f} on {n_shared:,} shared compounds — gradient conflict, negative-transfer risk",
+    )
+
+
+def _assess_extension(
+    r: float,
+    n_aux_only: int,
+    n_primary: int,
+    ratio_threshold: float,
+) -> tuple[str, str]:
+    """Score the extension region (aux-only compounds; primary head is masked there)."""
+    if n_aux_only == 0:
+        return ("None", "no aux-only compounds")
+
+    ratio = n_aux_only / n_primary if n_primary > 0 else 0.0
+    has_volume = ratio >= ratio_threshold
+
+    if np.isnan(r):
+        sim_str = "task similarity unknown (no overlap to measure)"
+        if has_volume:
+            return ("Strong", f"{ratio:.1f}x primary of novel chemistry; {sim_str}")
+        return ("Modest", f"{n_aux_only:,} aux-only compounds ({ratio:.1f}x primary); {sim_str}")
+
+    similar = r >= 0.4
+    if has_volume and similar:
+        return ("Strong", f"{ratio:.1f}x primary of novel chemistry x similar task (r={r:.2f})")
+    if has_volume:
+        return ("Modest", f"{ratio:.1f}x primary of novel chemistry but weak similarity (r={r:.2f})")
+    if similar:
+        return ("Modest", f"limited volume ({ratio:.1f}x primary) but similar task (r={r:.2f})")
+    return ("Minimal", f"low volume ({ratio:.1f}x primary) and weak similarity (r={r:.2f})")
+
+
+def _combine_assessments(overlap: str, extension: str) -> tuple[str, str]:
+    """Combine overlap + extension scores into an actionable recommendation."""
+    if overlap == "Harmful":
+        if extension in ("Strong", "Modest"):
+            return ("Risky", "harmful overlap; extension might rescue but cross-task signal could hurt primary")
+        return ("Skip", "negative transfer from overlap with no extension to compensate")
+
+    if overlap == "Beneficial":
+        if extension in ("Strong", "Modest"):
+            return ("Use", "both mechanisms contribute lift")
+        return ("Use", "cross-task signal contributes lift")
+
+    # overlap is Neutral or N/A — extension is the only available mechanism
+    if extension == "Strong":
+        return ("Use", "extension is the primary lift mechanism")
+    if extension == "Modest":
+        return ("Marginal", "limited extension lift; consider domain knowledge")
+    return ("Skip", "no clear lift mechanism")
+
+
+# =============================================================================
+# Testing
+# =============================================================================
+if __name__ == "__main__":
+    from workbench.utils.synthetic_data_generator import SyntheticDataGenerator
+
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    pd.set_option("display.max_columns", None)
+    pd.set_option("display.width", 1400)
+
+    # Build a synthetic multi-task DataFrame from two AQSol partitions
+    ref_df, query_df = SyntheticDataGenerator().aqsol_alignment_data(overlap="medium", alignment="medium")
+    ref_df = ref_df.assign(id=ref_df["id"].astype(str).radd("ref_"))
+    query_df = query_df.assign(id=query_df["id"].astype(str).radd("qry_"))
+    ref_df = ref_df.rename(columns={"solubility": "primary_sol"})
+    query_df = query_df.rename(columns={"solubility": "aux_sol"})
+    mt_df = pd.concat(
+        [
+            ref_df[["id", "smiles", "primary_sol"]],
+            query_df[["id", "smiles", "aux_sol"]],
+        ],
+        ignore_index=True,
+    )
+
+    mta = MultiTaskAlignment(mt_df, primary="primary_sol", auxiliaries=["aux_sol"], id_column="id")
+
+    print("\n=== summary() ===")
+    print(mta.summary().to_string(index=False))
+
+    print("\n=== results() (first 5 rows) ===")
+    print(mta.results().head().to_string(index=False))
+
+    print("\nMultiTaskAlignment tests completed!")

workbench/api/endpoint.py

@@ -82,6 +82,23 @@ class Endpoint(EndpointCore):
             return self._async.auto_inference()
         return super().auto_inference()
 
+    def purge_async_queue(self) -> int:
+        """Cancel queued async invocations by deleting their staged S3 inputs.
+
+        Useful when a long-running client was killed and you want to abandon
+        the orphaned backlog instead of waiting for the fleet to drain it.
+        Only valid on async endpoints — raises on sync endpoints.
+
+        Returns:
+            int: Number of staged input objects deleted.
+        """
+        if self._async is None:
+            raise RuntimeError(
+                f"Endpoint '{self.name}' is not async — purge_async_queue is only "
+                f"meaningful for endpoints with an async invocation queue."
+            )
+        return self._async.purge_async_queue()
+
     def full_inference(self) -> pd.DataFrame:
         """Run inference on the Endpoint using the full data from the model training view
 

workbench/api/inference_cache.py

@@ -23,10 +23,7 @@ import pandas as pd
 
 from workbench.api.df_store import DFStore
 from workbench.api.endpoint import Endpoint
-from workbench.utils.inference_cache_utils import (
-    DEFAULT_CHUNK_SIZE,
-    chunked_with_cache_writes,
-)
+from workbench.utils.inference_cache_utils import chunked_with_cache_writes
 
 
 class InferenceCache:
@@ -49,33 +46,13 @@ class InferenceCache:
         ```
     """
 
-    # Rows per cache write. The endpoint is called once per chunk and the
-    # cache is persisted between chunks, so this also bounds the blast radius
-    # of an interrupted/failed write to one chunk worth of work.
-    #
-    # The actual chunk_size on each instance is set in __init__: either the
-    # explicit ``chunk_size`` constructor kwarg, or — for async endpoints with
-    # max_instances in their workbench_meta — derived from fleet capacity
-    # (max_instances × batch_size × 2) so each chunk holds an integer number
-    # of full fleet-waves. This avoids the "10 batches / 8 instances → tail"
-    # utilization loss. Falls back to this class attribute (DEFAULT_CHUNK_SIZE)
-    # for sync endpoints or legacy endpoints without max_instances in meta.
-    chunk_size: int = DEFAULT_CHUNK_SIZE
-
-    # Number of fleet-waves per chunk when auto-deriving chunk_size. With k
-    # batches per worker, relative tail-variance scales as 1/√k, so bumping
-    # k from 2 to 4 cuts tail overhead ~30% without changing batch_size (so
-    # per-batch polling cost is unchanged). Crash-recovery loss is one chunk
-    # = 4 fleet-waves of work, modest for any reasonable batch pipeline.
-    _CHUNK_WAVES = 4
-
     def __init__(
         self,
         endpoint: Endpoint,
         cache_key_column: str = "smiles",
         output_key_column: Optional[str] = None,
         auto_invalidate_cache: bool = False,
-        chunk_size: Optional[int] = None,
+        snapshot: int = 500,
     ):
         """Initialize the InferenceCache.
 
@@ -98,15 +75,16 @@ class InferenceCache:
                 kept regardless of endpoint changes — the manifest is
                 reseeded on first load so subsequent calls have a consistent
                 baseline.
-            chunk_size (Optional[int]): Rows per cache write. If ``None``
-                (default), derived from the endpoint's ``max_instances`` and
-                ``inference_batch_size`` to produce full fleet-waves — see
-                :meth:`_derive_chunk_size`. Falls back to
-                ``DEFAULT_CHUNK_SIZE`` when fleet info isn't available.
+            snapshot (int): Rows per cache write (default: 500). The
+                endpoint is called once per snapshot's worth of rows and the
+                cache is persisted between calls, so this also bounds the
+                blast radius of an interrupted run to one snapshot's worth
+                of work.
         """
         self._endpoint = endpoint
         self.cache_key_column = cache_key_column
         self.output_key_column = output_key_column
+        self.snapshot = int(snapshot)
         self.cache_path = f"/workbench/inference_cache/{endpoint.name}"
         self.manifest_path = f"{self.cache_path}__meta"
         self._df_store = DFStore()
@@ -122,49 +100,6 @@ class InferenceCache:
         self._coerce_warned: set[tuple] = set()
         self.log = logging.getLogger("workbench")
 
-        # Resolve chunk_size: explicit override wins; else try fleet-derivation;
-        # else fall through to the class-level DEFAULT_CHUNK_SIZE.
-        if chunk_size is not None:
-            self.chunk_size = int(chunk_size)
-        else:
-            derived = self._derive_chunk_size()
-            if derived is not None:
-                self.chunk_size = derived
-
-    def _derive_chunk_size(self) -> Optional[int]:
-        """Derive chunk_size from the wrapped endpoint's fleet capacity.
-
-        Returns ``capacity × batch_size × _CHUNK_WAVES`` so each chunk
-        holds an integer number of full fleet-waves — preventing the
-        "10 batches / 8 instances → 2-batch tail" utilization loss on async
-        endpoints. ``capacity`` prefers ``effective_max_instances`` when
-        present (set by MetaEndpoint to reflect the largest child fleet,
-        since the meta itself deploys with ``max_instances=1`` regardless
-        of downstream capacity), otherwise falls back to ``max_instances``.
-        Returns ``None`` (→ caller should use DEFAULT_CHUNK_SIZE) when the
-        endpoint's meta has neither, which is the case for sync endpoints
-        and legacy async deploys.
-        """
-        try:
-            meta = self._endpoint.workbench_meta() or {}
-        except Exception:
-            return None
-        capacity = meta.get("effective_max_instances", meta.get("max_instances"))
-        if capacity is None:
-            return None
-        # Mirror AsyncEndpointCore's own resolution: explicit meta override
-        # wins, otherwise the core default.
-        from workbench.core.artifacts.async_endpoint_core import _DEFAULT_BATCH_SIZE
-
-        batch_size = int(meta.get("inference_batch_size", _DEFAULT_BATCH_SIZE))
-        derived = int(capacity) * batch_size * self._CHUNK_WAVES
-        self.log.info(
-            f"InferenceCache[{self._endpoint.name}]: chunk_size={derived} "
-            f"(capacity={capacity} × batch_size={batch_size} × "
-            f"{self._CHUNK_WAVES} waves — full fleet utilization per chunk)"
-        )
-        return derived
-
     def __getattr__(self, name):
         """Delegate any unrecognized attribute access to the wrapped Endpoint."""
         # __getattr__ is only called when normal lookup fails, so this won't